--- a/components/desktop/polkit/Makefile	Fri Dec 02 10:06:19 2016 -0800
+++ b/components/desktop/polkit/Makefile	Wed Nov 23 13:15:13 2016 -0800
@@ -46,11 +46,7 @@
 TEST_TARGET = $(SKIP_TEST)
 
 # Needs gobject-introspection, not available on S11.
-ifeq ($(BUILD_TYPE), evaluation)
-BUILD_32_and_64=
-INSTALL_32_and_64=
-PUBLISH_STAMP=
-endif
+include $(WS_MAKE_RULES)/no-evaluation.mk
 
 include $(WS_MAKE_RULES)/common.mk
 
@@ -79,6 +75,11 @@
 CONFIGURE_OPTIONS += --with-os-type=solaris
 CONFIGURE_OPTIONS += --sysconfdir="$(ETCDIR)"
 
+# Workaround the mozjs issue described in 24935318
+LD_EXEC_OPTIONS += -M $(PWD)/../../gnome/gjs/mapfile
+ADIHEAP_MODE = $(ADIHEAP_DISABLE)
+ADISTACK_MODE = $(ADISTACK_DISABLE)
+
 # Largefile support breaks use of <procfs.h> when build environment is older
 # than s12_84 due to Solaris bug 21833491
 ifeq ($(OS_VERSION), 5.11)
@@ -97,6 +98,9 @@
 REQUIRED_PACKAGES += library/desktop/gobject/gobject-introspection
 REQUIRED_PACKAGES += library/expat
 REQUIRED_PACKAGES += library/glib2
+REQUIRED_PACKAGES += library/libmozjs-24
 REQUIRED_PACKAGES += system/core-os
 REQUIRED_PACKAGES += system/library/dbus
+REQUIRED_PACKAGES += system/library/gcc/gcc-c-runtime
+REQUIRED_PACKAGES += system/library/gcc/gcc-c++-runtime
 REQUIRED_PACKAGES += system/library/math

--- a/components/desktop/polkit/patches/02-duktape.patch	Fri Dec 02 10:06:19 2016 -0800
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,78465 +0,0 @@
-From 951c354472ae14af34a6a034ff0f79376cd085ed Mon Sep 17 00:00:00 2001
-From: "Jasper St. Pierre" <[email protected]>
-Date: Wed, 12 Aug 2015 16:04:31 -0700
-Subject: [PATCH] Port to duktape
-
----
- configure.ac                                    |   15 -
- src/polkitbackend/Makefile.am                   |    7 +-
- src/polkitbackend/duktape.c                     |72690 +++++++++++++++++++++++
- src/polkitbackend/duktape.h                     | 4460 ++
- src/polkitbackend/polkitbackendjsauthority.c    |  846 +-
- test/data/etc/polkit-1/rules.d/10-testing.rules |    2 +-
- 6 files changed, 77329 insertions(+), 691 deletions(-)
- create mode 100644 src/polkitbackend/duktape.c
- create mode 100644 src/polkitbackend/duktape.h
-
-diff --git a/configure.ac b/configure.ac
-index 85f26b9..29758be 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -129,21 +129,6 @@ AC_DEFINE([GLIB_VERSION_MIN_REQUIRED], [GLIB_VERSION_2_30],
- AC_DEFINE([GLIB_VERSION_MAX_ALLOWED], [G_ENCODE_VERSION(2,34)],
-         [Notify us when we'll need to transition away from g_type_init()])
- 
--AC_ARG_WITH(mozjs, AS_HELP_STRING([--with-mozjs=@<:@mozjs185/mozjs-17.0|auto@:>@],
--		                  [Specify version of Spidermonkey to use]),,
--            with_mozjs=auto)
--AS_IF([test x${with_mozjs} != xauto], [
--  PKG_CHECK_MODULES(LIBJS, ${with_mozjs})
--], [
--  PKG_CHECK_MODULES(LIBJS, [mozjs185], have_mozjs185=yes, have_mozjs185=no)
--  AS_IF([test x${have_mozjs185} = xno], [
--  PKG_CHECK_MODULES(LIBJS, [mozjs-17.0], have_mozjs17=yes,
--   [AC_MSG_ERROR([Could not find mozjs185 or mozjs-17.0; see http://ftp.mozilla.org/pub/mozilla.org/js/])])
--  ])
--])
--AC_SUBST(LIBJS_CFLAGS)
--AC_SUBST(LIBJS_LIBS)
--
- EXPAT_LIB=""
- AC_ARG_WITH(expat, [  --with-expat=<dir>      Use expat from here],
-                       [
-diff --git a/src/polkitbackend/Makefile.am b/src/polkitbackend/Makefile.am
-index 547ca82..ef6a9dd 100644
---- a/src/polkitbackend/Makefile.am
-+++ b/src/polkitbackend/Makefile.am
-@@ -36,6 +36,7 @@ libpolkit_backend_1_la_SOURCES =                                   			\
- 	polkitbackendactionpool.h		polkitbackendactionpool.c		\
- 	polkitbackendconfigsource.h		polkitbackendconfigsource.c		\
- 	polkitbackendactionlookup.h		polkitbackendactionlookup.c		\
-+	duktape.c duktape.h \
-         $(NULL)
- 
- if HAVE_LIBSYSTEMD
-@@ -49,9 +50,11 @@ endif
- libpolkit_backend_1_la_CFLAGS =                                        	\
-         -D_POLKIT_COMPILATION                                  		\
-         -D_POLKIT_BACKEND_COMPILATION                                  	\
-+	-DDUK_OPT_HAVE_CUSTOM_H						\
-+	-DDUK_OPT_INTERRUPT_COUNTER					\
-+	-D'DUK_OPT_EXEC_TIMEOUT_CHECK(u)=polkit_js_exec_timeout_check(u)' \
-         $(GLIB_CFLAGS)							\
- 	$(LIBSYSTEMD_CFLAGS)						\
--	$(LIBJS_CFLAGS)							\
-         $(NULL)
- 
- libpolkit_backend_1_la_LIBADD =                               		\
-@@ -59,7 +62,7 @@ libpolkit_backend_1_la_LIBADD =                               		\
- 	$(LIBSYSTEMD_LIBS)						\
- 	$(top_builddir)/src/polkit/libpolkit-gobject-1.la		\
- 	$(EXPAT_LIBS)							\
--	$(LIBJS_LIBS)							\
-+	-lm								\
-         $(NULL)
- 
- rulesdir = $(sysconfdir)/polkit-1/rules.d
-diff --git a/src/polkitbackend/duktape.c b/src/polkitbackend/duktape.c
-new file mode 100644
-index 0000000..cb39caf
---- /dev/null
-+++ b/src/polkitbackend/duktape.c
-@@ -0,0 +1,72690 @@
-+/*
-+ *  Single file autogenerated distributable for Duktape 1.2.3.
-+ *  Git commit 0605a18660dbae486c62a42a33fabd034c8623ff (v1.2.3).
-+ *
-+ *  See Duktape AUTHORS.rst and LICENSE.txt for copyright and
-+ *  licensing information.
-+ */
-+
-+/* LICENSE.txt */
-+/*
-+*  ===============
-+*  Duktape license
-+*  ===============
-+*
-+*  (http://opensource.org/licenses/MIT)
-+*
-+*  Copyright (c) 2013-2015 by Duktape authors (see AUTHORS.rst)
-+*
-+*  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.
-+*
-+*/
-+/* AUTHORS.rst */
-+/*
-+*  ===============
-+*  Duktape authors
-+*  ===============
-+*
-+*  Copyright
-+*  =========
-+*
-+*  Duktape copyrights are held by its authors.  Each author has a copyright
-+*  to their contribution, and agrees to irrevocably license the contribution
-+*  under the Duktape ``LICENSE.txt``.
-+*
-+*  Authors
-+*  =======
-+*
-+*  Please include an e-mail address, a link to your GitHub profile, or something
-+*  similar to allow your contribution to be identified accurately.
-+*
-+*  The following people have contributed code and agreed to irrevocably license
-+*  their contributions under the Duktape ``LICENSE.txt`` (in order of appearance):
-+*
-+*  * Sami Vaarala <[email protected]>
-+*  * Niki Dobrev
-+*  * Andreas \u00d6man <[email protected]>
-+*  * L\u00e1szl\u00f3 Lang\u00f3 <[email protected]>
-+*  * Legimet <[email protected]>
-+*
-+*  Other contributions
-+*  ===================
-+*
-+*  The following people have contributed something other than code (e.g. reported
-+*  bugs, provided ideas, etc; roughly in order of appearance):
-+*
-+*  * Greg Burns
-+*  * Anthony Rabine
-+*  * Carlos Costa
-+*  * Aur\u00e9lien Bouilland
-+*  * Preet Desai (Pris Matic)
-+*  * judofyr (http://www.reddit.com/user/judofyr)
-+*  * Jason Woofenden
-+*  * Micha\u0142 Przyby\u015b
-+*  * Anthony Howe
-+*  * Conrad Pankoff
-+*  * Jim Schimpf
-+*  * Rajaran Gaunker (https://github.com/zimbabao)
-+*  * Andreas \u00d6man
-+*  * Doug Sanden
-+*  * Josh Engebretson (https://github.com/JoshEngebretson)
-+*  * Remo Eichenberger (https://github.com/remoe)
-+*  * Mamod Mehyar (https://github.com/mamod)
-+*  * David Demelier (https://github.com/hftmarkand)
-+*  * Tim Caswell (https://github.com/creationix)
-+*  * Mitchell Blank Jr (https://github.com/mitchblank)
-+*  * https://github.com/yushli
-+*  * Seo Sanghyeon (https://github.com/sanxiyn)
-+*  * Han ChoongWoo (https://github.com/tunz)
-+*  * Joshua Peek (https://github.com/josh)
-+*  * Bruce E. Pascoe (https://github.com/fatcerberus)
-+*  * https://github.com/Kelledin
-+*  * https://github.com/sstruchtrup
-+*
-+*  If you are accidentally missing from this list, send me an e-mail
-+*  (``[email protected]``) and I'll fix the omission.
-+*/
-+#line 1 "duk_internal.h"
-+/*
-+ *  Top-level include file to be used for all (internal) source files.
-+ *
-+ *  Source files should not include individual header files, as they
-+ *  have not been designed to be individually included.
-+ */
-+
-+#ifndef DUK_INTERNAL_H_INCLUDED
-+#define DUK_INTERNAL_H_INCLUDED
-+
-+/*
-+ *  The 'duktape.h' header provides the public API, but also handles all
-+ *  compiler and platform specific feature detection, Duktape feature
-+ *  resolution, inclusion of system headers, etc.  These have been merged
-+ *  because the public API is also dependent on e.g. detecting appropriate
-+ *  C types which is quite platform/compiler specific especially for a non-C99
-+ *  build.  The public API is also dependent on the resolved feature set.
-+ *
-+ *  Some actions taken by the merged header (such as including system headers)
-+ *  are not appropriate for building a user application.  The define
-+ *  DUK_COMPILING_DUKTAPE allows the merged header to skip/include some
-+ *  sections depending on what is being built.
-+ */
-+
-+#define DUK_COMPILING_DUKTAPE
-+#include "duktape.h"
-+
-+/*
-+ *  User declarations, e.g. prototypes for user functions used by Duktape
-+ *  macros.  Concretely, if DUK_OPT_PANIC_HANDLER is used and the macro
-+ *  value calls a user function, it needs to be declared for Duktape
-+ *  compilation to avoid warnings.
-+ */
-+
-+DUK_USE_USER_DECLARE()
-+
-+/*
-+ *  Duktape includes (other than duk_features.h)
-+ *
-+ *  The header files expect to be included in an order which satisfies header
-+ *  dependencies correctly (the headers themselves don't include any other
-+ *  includes).  Forward declarations are used to break circular struct/typedef
-+ *  dependencies.
-+ */
-+
-+#line 1 "duk_replacements.h"
-+#ifndef DUK_REPLACEMENTS_H_INCLUDED
-+#define DUK_REPLACEMENTS_H_INCLUDED
-+
-+#ifdef DUK_USE_REPL_FPCLASSIFY
-+DUK_INTERNAL_DECL int duk_repl_fpclassify(double x);
-+#endif
-+
-+#ifdef DUK_USE_REPL_SIGNBIT
-+DUK_INTERNAL_DECL int duk_repl_signbit(double x);
-+#endif
-+
-+#ifdef DUK_USE_REPL_ISFINITE
-+DUK_INTERNAL_DECL int duk_repl_isfinite(double x);
-+#endif
-+
-+#ifdef DUK_USE_REPL_ISNAN
-+DUK_INTERNAL_DECL int duk_repl_isnan(double x);
-+#endif
-+
-+#ifdef DUK_USE_REPL_ISINF
-+DUK_INTERNAL_DECL int duk_repl_isinf(double x);
-+#endif
-+
-+#endif  /* DUK_REPLACEMENTS_H_INCLUDED */
-+#line 1 "duk_jmpbuf.h"
-+/*
-+ *  Wrapper for jmp_buf.
-+ *
-+ *  This is used because jmp_buf is an array type for backward compatibility.
-+ *  Wrapping jmp_buf in a struct makes pointer references, sizeof, etc,
-+ *  behave more intuitively.
-+ *
-+ *  http://en.wikipedia.org/wiki/Setjmp.h#Member_types
-+ */
-+
-+#ifndef DUK_JMPBUF_H_INCLUDED
-+#define DUK_JMPBUF_H_INCLUDED
-+
-+struct duk_jmpbuf {
-+#if defined(DUK_USE_SETJMP) || defined(DUK_USE_UNDERSCORE_SETJMP)
-+	jmp_buf jb;
-+#elif defined(DUK_USE_SIGSETJMP)
-+	sigjmp_buf jb;
-+#else
-+#error internal error, no long control transfer provider
-+#endif
-+};
-+
-+#endif  /* DUK_JMPBUF_H_INCLUDED */
-+#line 1 "duk_forwdecl.h"
-+/*
-+ *  Forward declarations for all Duktape structures.
-+ */
-+
-+#ifndef DUK_FORWDECL_H_INCLUDED
-+#define DUK_FORWDECL_H_INCLUDED
-+
-+/*
-+ *  Forward declarations
-+ */
-+
-+struct duk_jmpbuf;
-+
-+/* duk_tval intentionally skipped */
-+struct duk_heaphdr;
-+struct duk_heaphdr_string;
-+struct duk_hstring;
-+struct duk_hstring_external;
-+struct duk_hobject;
-+struct duk_hcompiledfunction;
-+struct duk_hnativefunction;
-+struct duk_hthread;
-+struct duk_hbuffer;
-+struct duk_hbuffer_fixed;
-+struct duk_hbuffer_dynamic;
-+
-+struct duk_propaccessor;
-+union duk_propvalue;
-+struct duk_propdesc;
-+
-+struct duk_heap;
-+struct duk_breakpoint;
-+
-+struct duk_activation;
-+struct duk_catcher;
-+struct duk_strcache;
-+struct duk_ljstate;
-+struct duk_strtab_entry;
-+
-+#ifdef DUK_USE_DEBUG
-+struct duk_fixedbuffer;
-+#endif
-+
-+struct duk_bitdecoder_ctx;
-+struct duk_bitencoder_ctx;
-+
-+struct duk_token;
-+struct duk_re_token;
-+struct duk_lexer_point;
-+struct duk_lexer_ctx;
-+
-+struct duk_compiler_instr;
-+struct duk_compiler_func;
-+struct duk_compiler_ctx;
-+
-+struct duk_re_matcher_ctx;
-+struct duk_re_compiler_ctx;
-+
-+typedef struct duk_jmpbuf duk_jmpbuf;
-+
-+/* duk_tval intentionally skipped */
-+typedef struct duk_heaphdr duk_heaphdr;
-+typedef struct duk_heaphdr_string duk_heaphdr_string;
-+typedef struct duk_hstring duk_hstring;
-+typedef struct duk_hstring_external duk_hstring_external;
-+typedef struct duk_hobject duk_hobject;
-+typedef struct duk_hcompiledfunction duk_hcompiledfunction;
-+typedef struct duk_hnativefunction duk_hnativefunction;
-+typedef struct duk_hthread duk_hthread;
-+typedef struct duk_hbuffer duk_hbuffer;
-+typedef struct duk_hbuffer_fixed duk_hbuffer_fixed;
-+typedef struct duk_hbuffer_dynamic duk_hbuffer_dynamic;
-+
-+typedef struct duk_propaccessor duk_propaccessor;
-+typedef union duk_propvalue duk_propvalue;
-+typedef struct duk_propdesc duk_propdesc;
-+
-+typedef struct duk_heap duk_heap;
-+typedef struct duk_breakpoint duk_breakpoint;
-+
-+typedef struct duk_activation duk_activation;
-+typedef struct duk_catcher duk_catcher;
-+typedef struct duk_strcache duk_strcache;
-+typedef struct duk_ljstate duk_ljstate;
-+typedef struct duk_strtab_entry duk_strtab_entry;
-+
-+#ifdef DUK_USE_DEBUG
-+typedef struct duk_fixedbuffer duk_fixedbuffer;
-+#endif
-+
-+typedef struct duk_bitdecoder_ctx duk_bitdecoder_ctx;
-+typedef struct duk_bitencoder_ctx duk_bitencoder_ctx;
-+
-+typedef struct duk_token duk_token;
-+typedef struct duk_re_token duk_re_token;
-+typedef struct duk_lexer_point duk_lexer_point;
-+typedef struct duk_lexer_ctx duk_lexer_ctx;
-+
-+typedef struct duk_compiler_instr duk_compiler_instr;
-+typedef struct duk_compiler_func duk_compiler_func;
-+typedef struct duk_compiler_ctx duk_compiler_ctx;
-+
-+typedef struct duk_re_matcher_ctx duk_re_matcher_ctx;
-+typedef struct duk_re_compiler_ctx duk_re_compiler_ctx;
-+
-+#endif  /* DUK_FORWDECL_H_INCLUDED */
-+#line 1 "duk_builtins.h"
-+/*
-+ *  Automatically generated by genbuiltins.py, do not edit!
-+ */
-+
-+#ifndef DUK_BUILTINS_H_INCLUDED
-+#define DUK_BUILTINS_H_INCLUDED
-+
-+#if defined(DUK_USE_DOUBLE_LE)
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943];
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STRDATA_DATA_LENGTH                                       1943
-+#define DUK_STRDATA_MAX_STRLEN                                        24
-+
-+#define DUK_STRIDX_UC_LOGGER                                          0                              /* 'Logger' */
-+#define DUK_STRIDX_UC_THREAD                                          1                              /* 'Thread' */
-+#define DUK_STRIDX_UC_POINTER                                         2                              /* 'Pointer' */
-+#define DUK_STRIDX_UC_BUFFER                                          3                              /* 'Buffer' */
-+#define DUK_STRIDX_DEC_ENV                                            4                              /* 'DecEnv' */
-+#define DUK_STRIDX_OBJ_ENV                                            5                              /* 'ObjEnv' */
-+#define DUK_STRIDX_EMPTY_STRING                                       6                              /* '' */
-+#define DUK_STRIDX_GLOBAL                                             7                              /* 'global' */
-+#define DUK_STRIDX_UC_ARGUMENTS                                       8                              /* 'Arguments' */
-+#define DUK_STRIDX_JSON                                               9                              /* 'JSON' */
-+#define DUK_STRIDX_MATH                                               10                             /* 'Math' */
-+#define DUK_STRIDX_UC_ERROR                                           11                             /* 'Error' */
-+#define DUK_STRIDX_REG_EXP                                            12                             /* 'RegExp' */
-+#define DUK_STRIDX_DATE                                               13                             /* 'Date' */
-+#define DUK_STRIDX_UC_NUMBER                                          14                             /* 'Number' */
-+#define DUK_STRIDX_UC_BOOLEAN                                         15                             /* 'Boolean' */
-+#define DUK_STRIDX_UC_STRING                                          16                             /* 'String' */
-+#define DUK_STRIDX_ARRAY                                              17                             /* 'Array' */
-+#define DUK_STRIDX_UC_FUNCTION                                        18                             /* 'Function' */
-+#define DUK_STRIDX_UC_OBJECT                                          19                             /* 'Object' */
-+#define DUK_STRIDX_UC_NULL                                            20                             /* 'Null' */
-+#define DUK_STRIDX_UC_UNDEFINED                                       21                             /* 'Undefined' */
-+#define DUK_STRIDX_JSON_EXT_FUNCTION2                                 22                             /* '{_func:true}' */
-+#define DUK_STRIDX_JSON_EXT_FUNCTION1                                 23                             /* '{"_func":true}' */
-+#define DUK_STRIDX_JSON_EXT_NEGINF                                    24                             /* '{"_ninf":true}' */
-+#define DUK_STRIDX_JSON_EXT_POSINF                                    25                             /* '{"_inf":true}' */
-+#define DUK_STRIDX_JSON_EXT_NAN                                       26                             /* '{"_nan":true}' */
-+#define DUK_STRIDX_JSON_EXT_UNDEFINED                                 27                             /* '{"_undef":true}' */
-+#define DUK_STRIDX_TO_LOG_STRING                                      28                             /* 'toLogString' */
-+#define DUK_STRIDX_CLOG                                               29                             /* 'clog' */
-+#define DUK_STRIDX_LC_L                                               30                             /* 'l' */
-+#define DUK_STRIDX_LC_N                                               31                             /* 'n' */
-+#define DUK_STRIDX_LC_FATAL                                           32                             /* 'fatal' */
-+#define DUK_STRIDX_LC_ERROR                                           33                             /* 'error' */
-+#define DUK_STRIDX_LC_WARN                                            34                             /* 'warn' */
-+#define DUK_STRIDX_LC_DEBUG                                           35                             /* 'debug' */
-+#define DUK_STRIDX_LC_TRACE                                           36                             /* 'trace' */
-+#define DUK_STRIDX_RAW                                                37                             /* 'raw' */
-+#define DUK_STRIDX_FMT                                                38                             /* 'fmt' */
-+#define DUK_STRIDX_CURRENT                                            39                             /* 'current' */
-+#define DUK_STRIDX_RESUME                                             40                             /* 'resume' */
-+#define DUK_STRIDX_COMPACT                                            41                             /* 'compact' */
-+#define DUK_STRIDX_JC                                                 42                             /* 'jc' */
-+#define DUK_STRIDX_JX                                                 43                             /* 'jx' */
-+#define DUK_STRIDX_BASE64                                             44                             /* 'base64' */
-+#define DUK_STRIDX_HEX                                                45                             /* 'hex' */
-+#define DUK_STRIDX_DEC                                                46                             /* 'dec' */
-+#define DUK_STRIDX_ENC                                                47                             /* 'enc' */
-+#define DUK_STRIDX_FIN                                                48                             /* 'fin' */
-+#define DUK_STRIDX_GC                                                 49                             /* 'gc' */
-+#define DUK_STRIDX_ACT                                                50                             /* 'act' */
-+#define DUK_STRIDX_LC_INFO                                            51                             /* 'info' */
-+#define DUK_STRIDX_VERSION                                            52                             /* 'version' */
-+#define DUK_STRIDX_ENV                                                53                             /* 'env' */
-+#define DUK_STRIDX_MOD_LOADED                                         54                             /* 'modLoaded' */
-+#define DUK_STRIDX_MOD_SEARCH                                         55                             /* 'modSearch' */
-+#define DUK_STRIDX_ERR_THROW                                          56                             /* 'errThrow' */
-+#define DUK_STRIDX_ERR_CREATE                                         57                             /* 'errCreate' */
-+#define DUK_STRIDX_COMPILE                                            58                             /* 'compile' */
-+#define DUK_STRIDX_INT_REGBASE                                        59                             /* '\x00Regbase' */
-+#define DUK_STRIDX_INT_THREAD                                         60                             /* '\x00Thread' */
-+#define DUK_STRIDX_INT_HANDLER                                        61                             /* '\x00Handler' */
-+#define DUK_STRIDX_INT_FINALIZER                                      62                             /* '\x00Finalizer' */
-+#define DUK_STRIDX_INT_CALLEE                                         63                             /* '\x00Callee' */
-+#define DUK_STRIDX_INT_MAP                                            64                             /* '\x00Map' */
-+#define DUK_STRIDX_INT_ARGS                                           65                             /* '\x00Args' */
-+#define DUK_STRIDX_INT_THIS                                           66                             /* '\x00This' */
-+#define DUK_STRIDX_INT_PC2LINE                                        67                             /* '\x00Pc2line' */
-+#define DUK_STRIDX_INT_SOURCE                                         68                             /* '\x00Source' */
-+#define DUK_STRIDX_INT_VARENV                                         69                             /* '\x00Varenv' */
-+#define DUK_STRIDX_INT_LEXENV                                         70                             /* '\x00Lexenv' */
-+#define DUK_STRIDX_INT_VARMAP                                         71                             /* '\x00Varmap' */
-+#define DUK_STRIDX_INT_FORMALS                                        72                             /* '\x00Formals' */
-+#define DUK_STRIDX_INT_BYTECODE                                       73                             /* '\x00Bytecode' */
-+#define DUK_STRIDX_INT_NEXT                                           74                             /* '\x00Next' */
-+#define DUK_STRIDX_INT_TARGET                                         75                             /* '\x00Target' */
-+#define DUK_STRIDX_INT_VALUE                                          76                             /* '\x00Value' */
-+#define DUK_STRIDX_LC_POINTER                                         77                             /* 'pointer' */
-+#define DUK_STRIDX_LC_BUFFER                                          78                             /* 'buffer' */
-+#define DUK_STRIDX_INT_TRACEDATA                                      79                             /* '\x00Tracedata' */
-+#define DUK_STRIDX_LINE_NUMBER                                        80                             /* 'lineNumber' */
-+#define DUK_STRIDX_FILE_NAME                                          81                             /* 'fileName' */
-+#define DUK_STRIDX_PC                                                 82                             /* 'pc' */
-+#define DUK_STRIDX_STACK                                              83                             /* 'stack' */
-+#define DUK_STRIDX_THROW_TYPE_ERROR                                   84                             /* 'ThrowTypeError' */
-+#define DUK_STRIDX_DUKTAPE                                            85                             /* 'Duktape' */
-+#define DUK_STRIDX_ID                                                 86                             /* 'id' */
-+#define DUK_STRIDX_REQUIRE                                            87                             /* 'require' */
-+#define DUK_STRIDX___PROTO__                                          88                             /* '__proto__' */
-+#define DUK_STRIDX_SET_PROTOTYPE_OF                                   89                             /* 'setPrototypeOf' */
-+#define DUK_STRIDX_OWN_KEYS                                           90                             /* 'ownKeys' */
-+#define DUK_STRIDX_ENUMERATE                                          91                             /* 'enumerate' */
-+#define DUK_STRIDX_DELETE_PROPERTY                                    92                             /* 'deleteProperty' */
-+#define DUK_STRIDX_HAS                                                93                             /* 'has' */
-+#define DUK_STRIDX_PROXY                                              94                             /* 'Proxy' */
-+#define DUK_STRIDX_CALLEE                                             95                             /* 'callee' */
-+#define DUK_STRIDX_INVALID_DATE                                       96                             /* 'Invalid Date' */
-+#define DUK_STRIDX_BRACKETED_ELLIPSIS                                 97                             /* '[...]' */
-+#define DUK_STRIDX_NEWLINE_TAB                                        98                             /* '\n\t' */
-+#define DUK_STRIDX_SPACE                                              99                             /* ' ' */
-+#define DUK_STRIDX_COMMA                                              100                            /* ',' */
-+#define DUK_STRIDX_MINUS_ZERO                                         101                            /* '-0' */
-+#define DUK_STRIDX_PLUS_ZERO                                          102                            /* '+0' */
-+#define DUK_STRIDX_ZERO                                               103                            /* '0' */
-+#define DUK_STRIDX_MINUS_INFINITY                                     104                            /* '-Infinity' */
-+#define DUK_STRIDX_PLUS_INFINITY                                      105                            /* '+Infinity' */
-+#define DUK_STRIDX_INFINITY                                           106                            /* 'Infinity' */
-+#define DUK_STRIDX_LC_OBJECT                                          107                            /* 'object' */
-+#define DUK_STRIDX_LC_STRING                                          108                            /* 'string' */
-+#define DUK_STRIDX_LC_NUMBER                                          109                            /* 'number' */
-+#define DUK_STRIDX_LC_BOOLEAN                                         110                            /* 'boolean' */
-+#define DUK_STRIDX_LC_UNDEFINED                                       111                            /* 'undefined' */
-+#define DUK_STRIDX_STRINGIFY                                          112                            /* 'stringify' */
-+#define DUK_STRIDX_TAN                                                113                            /* 'tan' */
-+#define DUK_STRIDX_SQRT                                               114                            /* 'sqrt' */
-+#define DUK_STRIDX_SIN                                                115                            /* 'sin' */
-+#define DUK_STRIDX_ROUND                                              116                            /* 'round' */
-+#define DUK_STRIDX_RANDOM                                             117                            /* 'random' */
-+#define DUK_STRIDX_POW                                                118                            /* 'pow' */
-+#define DUK_STRIDX_MIN                                                119                            /* 'min' */
-+#define DUK_STRIDX_MAX                                                120                            /* 'max' */
-+#define DUK_STRIDX_LOG                                                121                            /* 'log' */
-+#define DUK_STRIDX_FLOOR                                              122                            /* 'floor' */
-+#define DUK_STRIDX_EXP                                                123                            /* 'exp' */
-+#define DUK_STRIDX_COS                                                124                            /* 'cos' */
-+#define DUK_STRIDX_CEIL                                               125                            /* 'ceil' */
-+#define DUK_STRIDX_ATAN2                                              126                            /* 'atan2' */
-+#define DUK_STRIDX_ATAN                                               127                            /* 'atan' */
-+#define DUK_STRIDX_ASIN                                               128                            /* 'asin' */
-+#define DUK_STRIDX_ACOS                                               129                            /* 'acos' */
-+#define DUK_STRIDX_ABS                                                130                            /* 'abs' */
-+#define DUK_STRIDX_SQRT2                                              131                            /* 'SQRT2' */
-+#define DUK_STRIDX_SQRT1_2                                            132                            /* 'SQRT1_2' */
-+#define DUK_STRIDX_PI                                                 133                            /* 'PI' */
-+#define DUK_STRIDX_LOG10E                                             134                            /* 'LOG10E' */
-+#define DUK_STRIDX_LOG2E                                              135                            /* 'LOG2E' */
-+#define DUK_STRIDX_LN2                                                136                            /* 'LN2' */
-+#define DUK_STRIDX_LN10                                               137                            /* 'LN10' */
-+#define DUK_STRIDX_E                                                  138                            /* 'E' */
-+#define DUK_STRIDX_MESSAGE                                            139                            /* 'message' */
-+#define DUK_STRIDX_NAME                                               140                            /* 'name' */
-+#define DUK_STRIDX_INPUT                                              141                            /* 'input' */
-+#define DUK_STRIDX_INDEX                                              142                            /* 'index' */
-+#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP                               143                            /* '(?:)' */
-+#define DUK_STRIDX_LAST_INDEX                                         144                            /* 'lastIndex' */
-+#define DUK_STRIDX_MULTILINE                                          145                            /* 'multiline' */
-+#define DUK_STRIDX_IGNORE_CASE                                        146                            /* 'ignoreCase' */
-+#define DUK_STRIDX_SOURCE                                             147                            /* 'source' */
-+#define DUK_STRIDX_TEST                                               148                            /* 'test' */
-+#define DUK_STRIDX_EXEC                                               149                            /* 'exec' */
-+#define DUK_STRIDX_TO_GMT_STRING                                      150                            /* 'toGMTString' */
-+#define DUK_STRIDX_SET_YEAR                                           151                            /* 'setYear' */
-+#define DUK_STRIDX_GET_YEAR                                           152                            /* 'getYear' */
-+#define DUK_STRIDX_TO_JSON                                            153                            /* 'toJSON' */
-+#define DUK_STRIDX_TO_ISO_STRING                                      154                            /* 'toISOString' */
-+#define DUK_STRIDX_TO_UTC_STRING                                      155                            /* 'toUTCString' */
-+#define DUK_STRIDX_SET_UTC_FULL_YEAR                                  156                            /* 'setUTCFullYear' */
-+#define DUK_STRIDX_SET_FULL_YEAR                                      157                            /* 'setFullYear' */
-+#define DUK_STRIDX_SET_UTC_MONTH                                      158                            /* 'setUTCMonth' */
-+#define DUK_STRIDX_SET_MONTH                                          159                            /* 'setMonth' */
-+#define DUK_STRIDX_SET_UTC_DATE                                       160                            /* 'setUTCDate' */
-+#define DUK_STRIDX_SET_DATE                                           161                            /* 'setDate' */
-+#define DUK_STRIDX_SET_UTC_HOURS                                      162                            /* 'setUTCHours' */
-+#define DUK_STRIDX_SET_HOURS                                          163                            /* 'setHours' */
-+#define DUK_STRIDX_SET_UTC_MINUTES                                    164                            /* 'setUTCMinutes' */
-+#define DUK_STRIDX_SET_MINUTES                                        165                            /* 'setMinutes' */
-+#define DUK_STRIDX_SET_UTC_SECONDS                                    166                            /* 'setUTCSeconds' */
-+#define DUK_STRIDX_SET_SECONDS                                        167                            /* 'setSeconds' */
-+#define DUK_STRIDX_SET_UTC_MILLISECONDS                               168                            /* 'setUTCMilliseconds' */
-+#define DUK_STRIDX_SET_MILLISECONDS                                   169                            /* 'setMilliseconds' */
-+#define DUK_STRIDX_SET_TIME                                           170                            /* 'setTime' */
-+#define DUK_STRIDX_GET_TIMEZONE_OFFSET                                171                            /* 'getTimezoneOffset' */
-+#define DUK_STRIDX_GET_UTC_MILLISECONDS                               172                            /* 'getUTCMilliseconds' */
-+#define DUK_STRIDX_GET_MILLISECONDS                                   173                            /* 'getMilliseconds' */
-+#define DUK_STRIDX_GET_UTC_SECONDS                                    174                            /* 'getUTCSeconds' */
-+#define DUK_STRIDX_GET_SECONDS                                        175                            /* 'getSeconds' */
-+#define DUK_STRIDX_GET_UTC_MINUTES                                    176                            /* 'getUTCMinutes' */
-+#define DUK_STRIDX_GET_MINUTES                                        177                            /* 'getMinutes' */
-+#define DUK_STRIDX_GET_UTC_HOURS                                      178                            /* 'getUTCHours' */
-+#define DUK_STRIDX_GET_HOURS                                          179                            /* 'getHours' */
-+#define DUK_STRIDX_GET_UTC_DAY                                        180                            /* 'getUTCDay' */
-+#define DUK_STRIDX_GET_DAY                                            181                            /* 'getDay' */
-+#define DUK_STRIDX_GET_UTC_DATE                                       182                            /* 'getUTCDate' */
-+#define DUK_STRIDX_GET_DATE                                           183                            /* 'getDate' */
-+#define DUK_STRIDX_GET_UTC_MONTH                                      184                            /* 'getUTCMonth' */
-+#define DUK_STRIDX_GET_MONTH                                          185                            /* 'getMonth' */
-+#define DUK_STRIDX_GET_UTC_FULL_YEAR                                  186                            /* 'getUTCFullYear' */
-+#define DUK_STRIDX_GET_FULL_YEAR                                      187                            /* 'getFullYear' */
-+#define DUK_STRIDX_GET_TIME                                           188                            /* 'getTime' */
-+#define DUK_STRIDX_TO_LOCALE_TIME_STRING                              189                            /* 'toLocaleTimeString' */
-+#define DUK_STRIDX_TO_LOCALE_DATE_STRING                              190                            /* 'toLocaleDateString' */
-+#define DUK_STRIDX_TO_TIME_STRING                                     191                            /* 'toTimeString' */
-+#define DUK_STRIDX_TO_DATE_STRING                                     192                            /* 'toDateString' */
-+#define DUK_STRIDX_NOW                                                193                            /* 'now' */
-+#define DUK_STRIDX_UTC                                                194                            /* 'UTC' */
-+#define DUK_STRIDX_PARSE                                              195                            /* 'parse' */
-+#define DUK_STRIDX_TO_PRECISION                                       196                            /* 'toPrecision' */
-+#define DUK_STRIDX_TO_EXPONENTIAL                                     197                            /* 'toExponential' */
-+#define DUK_STRIDX_TO_FIXED                                           198                            /* 'toFixed' */
-+#define DUK_STRIDX_POSITIVE_INFINITY                                  199                            /* 'POSITIVE_INFINITY' */
-+#define DUK_STRIDX_NEGATIVE_INFINITY                                  200                            /* 'NEGATIVE_INFINITY' */
-+#define DUK_STRIDX_NAN                                                201                            /* 'NaN' */
-+#define DUK_STRIDX_MIN_VALUE                                          202                            /* 'MIN_VALUE' */
-+#define DUK_STRIDX_MAX_VALUE                                          203                            /* 'MAX_VALUE' */
-+#define DUK_STRIDX_SUBSTR                                             204                            /* 'substr' */
-+#define DUK_STRIDX_TRIM                                               205                            /* 'trim' */
-+#define DUK_STRIDX_TO_LOCALE_UPPER_CASE                               206                            /* 'toLocaleUpperCase' */
-+#define DUK_STRIDX_TO_UPPER_CASE                                      207                            /* 'toUpperCase' */
-+#define DUK_STRIDX_TO_LOCALE_LOWER_CASE                               208                            /* 'toLocaleLowerCase' */
-+#define DUK_STRIDX_TO_LOWER_CASE                                      209                            /* 'toLowerCase' */
-+#define DUK_STRIDX_SUBSTRING                                          210                            /* 'substring' */
-+#define DUK_STRIDX_SPLIT                                              211                            /* 'split' */
-+#define DUK_STRIDX_SEARCH                                             212                            /* 'search' */
-+#define DUK_STRIDX_REPLACE                                            213                            /* 'replace' */
-+#define DUK_STRIDX_MATCH                                              214                            /* 'match' */
-+#define DUK_STRIDX_LOCALE_COMPARE                                     215                            /* 'localeCompare' */
-+#define DUK_STRIDX_CHAR_CODE_AT                                       216                            /* 'charCodeAt' */
-+#define DUK_STRIDX_CHAR_AT                                            217                            /* 'charAt' */
-+#define DUK_STRIDX_FROM_CHAR_CODE                                     218                            /* 'fromCharCode' */
-+#define DUK_STRIDX_REDUCE_RIGHT                                       219                            /* 'reduceRight' */
-+#define DUK_STRIDX_REDUCE                                             220                            /* 'reduce' */
-+#define DUK_STRIDX_FILTER                                             221                            /* 'filter' */
-+#define DUK_STRIDX_MAP                                                222                            /* 'map' */
-+#define DUK_STRIDX_FOR_EACH                                           223                            /* 'forEach' */
-+#define DUK_STRIDX_SOME                                               224                            /* 'some' */
-+#define DUK_STRIDX_EVERY                                              225                            /* 'every' */
-+#define DUK_STRIDX_LAST_INDEX_OF                                      226                            /* 'lastIndexOf' */
-+#define DUK_STRIDX_INDEX_OF                                           227                            /* 'indexOf' */
-+#define DUK_STRIDX_UNSHIFT                                            228                            /* 'unshift' */
-+#define DUK_STRIDX_SPLICE                                             229                            /* 'splice' */
-+#define DUK_STRIDX_SORT                                               230                            /* 'sort' */
-+#define DUK_STRIDX_SLICE                                              231                            /* 'slice' */
-+#define DUK_STRIDX_SHIFT                                              232                            /* 'shift' */
-+#define DUK_STRIDX_REVERSE                                            233                            /* 'reverse' */
-+#define DUK_STRIDX_PUSH                                               234                            /* 'push' */
-+#define DUK_STRIDX_POP                                                235                            /* 'pop' */
-+#define DUK_STRIDX_JOIN                                               236                            /* 'join' */
-+#define DUK_STRIDX_CONCAT                                             237                            /* 'concat' */
-+#define DUK_STRIDX_IS_ARRAY                                           238                            /* 'isArray' */
-+#define DUK_STRIDX_LC_ARGUMENTS                                       239                            /* 'arguments' */
-+#define DUK_STRIDX_CALLER                                             240                            /* 'caller' */
-+#define DUK_STRIDX_BIND                                               241                            /* 'bind' */
-+#define DUK_STRIDX_CALL                                               242                            /* 'call' */
-+#define DUK_STRIDX_APPLY                                              243                            /* 'apply' */
-+#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE                             244                            /* 'propertyIsEnumerable' */
-+#define DUK_STRIDX_IS_PROTOTYPE_OF                                    245                            /* 'isPrototypeOf' */
-+#define DUK_STRIDX_HAS_OWN_PROPERTY                                   246                            /* 'hasOwnProperty' */
-+#define DUK_STRIDX_VALUE_OF                                           247                            /* 'valueOf' */
-+#define DUK_STRIDX_TO_LOCALE_STRING                                   248                            /* 'toLocaleString' */
-+#define DUK_STRIDX_TO_STRING                                          249                            /* 'toString' */
-+#define DUK_STRIDX_CONSTRUCTOR                                        250                            /* 'constructor' */
-+#define DUK_STRIDX_SET                                                251                            /* 'set' */
-+#define DUK_STRIDX_GET                                                252                            /* 'get' */
-+#define DUK_STRIDX_ENUMERABLE                                         253                            /* 'enumerable' */
-+#define DUK_STRIDX_CONFIGURABLE                                       254                            /* 'configurable' */
-+#define DUK_STRIDX_WRITABLE                                           255                            /* 'writable' */
-+#define DUK_STRIDX_VALUE                                              256                            /* 'value' */
-+#define DUK_STRIDX_KEYS                                               257                            /* 'keys' */
-+#define DUK_STRIDX_IS_EXTENSIBLE                                      258                            /* 'isExtensible' */
-+#define DUK_STRIDX_IS_FROZEN                                          259                            /* 'isFrozen' */
-+#define DUK_STRIDX_IS_SEALED                                          260                            /* 'isSealed' */
-+#define DUK_STRIDX_PREVENT_EXTENSIONS                                 261                            /* 'preventExtensions' */
-+#define DUK_STRIDX_FREEZE                                             262                            /* 'freeze' */
-+#define DUK_STRIDX_SEAL                                               263                            /* 'seal' */
-+#define DUK_STRIDX_DEFINE_PROPERTIES                                  264                            /* 'defineProperties' */
-+#define DUK_STRIDX_DEFINE_PROPERTY                                    265                            /* 'defineProperty' */
-+#define DUK_STRIDX_CREATE                                             266                            /* 'create' */
-+#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES                             267                            /* 'getOwnPropertyNames' */
-+#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR                        268                            /* 'getOwnPropertyDescriptor' */
-+#define DUK_STRIDX_GET_PROTOTYPE_OF                                   269                            /* 'getPrototypeOf' */
-+#define DUK_STRIDX_PROTOTYPE                                          270                            /* 'prototype' */
-+#define DUK_STRIDX_LENGTH                                             271                            /* 'length' */
-+#define DUK_STRIDX_ALERT                                              272                            /* 'alert' */
-+#define DUK_STRIDX_PRINT                                              273                            /* 'print' */
-+#define DUK_STRIDX_UNESCAPE                                           274                            /* 'unescape' */
-+#define DUK_STRIDX_ESCAPE                                             275                            /* 'escape' */
-+#define DUK_STRIDX_ENCODE_URI_COMPONENT                               276                            /* 'encodeURIComponent' */
-+#define DUK_STRIDX_ENCODE_URI                                         277                            /* 'encodeURI' */
-+#define DUK_STRIDX_DECODE_URI_COMPONENT                               278                            /* 'decodeURIComponent' */
-+#define DUK_STRIDX_DECODE_URI                                         279                            /* 'decodeURI' */
-+#define DUK_STRIDX_IS_FINITE                                          280                            /* 'isFinite' */
-+#define DUK_STRIDX_IS_NAN                                             281                            /* 'isNaN' */
-+#define DUK_STRIDX_PARSE_FLOAT                                        282                            /* 'parseFloat' */
-+#define DUK_STRIDX_PARSE_INT                                          283                            /* 'parseInt' */
-+#define DUK_STRIDX_EVAL                                               284                            /* 'eval' */
-+#define DUK_STRIDX_URI_ERROR                                          285                            /* 'URIError' */
-+#define DUK_STRIDX_TYPE_ERROR                                         286                            /* 'TypeError' */
-+#define DUK_STRIDX_SYNTAX_ERROR                                       287                            /* 'SyntaxError' */
-+#define DUK_STRIDX_REFERENCE_ERROR                                    288                            /* 'ReferenceError' */
-+#define DUK_STRIDX_RANGE_ERROR                                        289                            /* 'RangeError' */
-+#define DUK_STRIDX_EVAL_ERROR                                         290                            /* 'EvalError' */
-+#define DUK_STRIDX_BREAK                                              291                            /* 'break' */
-+#define DUK_STRIDX_CASE                                               292                            /* 'case' */
-+#define DUK_STRIDX_CATCH                                              293                            /* 'catch' */
-+#define DUK_STRIDX_CONTINUE                                           294                            /* 'continue' */
-+#define DUK_STRIDX_DEBUGGER                                           295                            /* 'debugger' */
-+#define DUK_STRIDX_DEFAULT                                            296                            /* 'default' */
-+#define DUK_STRIDX_DELETE                                             297                            /* 'delete' */
-+#define DUK_STRIDX_DO                                                 298                            /* 'do' */
-+#define DUK_STRIDX_ELSE                                               299                            /* 'else' */
-+#define DUK_STRIDX_FINALLY                                            300                            /* 'finally' */
-+#define DUK_STRIDX_FOR                                                301                            /* 'for' */
-+#define DUK_STRIDX_LC_FUNCTION                                        302                            /* 'function' */
-+#define DUK_STRIDX_IF                                                 303                            /* 'if' */
-+#define DUK_STRIDX_IN                                                 304                            /* 'in' */
-+#define DUK_STRIDX_INSTANCEOF                                         305                            /* 'instanceof' */
-+#define DUK_STRIDX_NEW                                                306                            /* 'new' */
-+#define DUK_STRIDX_RETURN                                             307                            /* 'return' */
-+#define DUK_STRIDX_SWITCH                                             308                            /* 'switch' */
-+#define DUK_STRIDX_THIS                                               309                            /* 'this' */
-+#define DUK_STRIDX_THROW                                              310                            /* 'throw' */
-+#define DUK_STRIDX_TRY                                                311                            /* 'try' */
-+#define DUK_STRIDX_TYPEOF                                             312                            /* 'typeof' */
-+#define DUK_STRIDX_VAR                                                313                            /* 'var' */
-+#define DUK_STRIDX_VOID                                               314                            /* 'void' */
-+#define DUK_STRIDX_WHILE                                              315                            /* 'while' */
-+#define DUK_STRIDX_WITH                                               316                            /* 'with' */
-+#define DUK_STRIDX_CLASS                                              317                            /* 'class' */
-+#define DUK_STRIDX_CONST                                              318                            /* 'const' */
-+#define DUK_STRIDX_ENUM                                               319                            /* 'enum' */
-+#define DUK_STRIDX_EXPORT                                             320                            /* 'export' */
-+#define DUK_STRIDX_EXTENDS                                            321                            /* 'extends' */
-+#define DUK_STRIDX_IMPORT                                             322                            /* 'import' */
-+#define DUK_STRIDX_SUPER                                              323                            /* 'super' */
-+#define DUK_STRIDX_LC_NULL                                            324                            /* 'null' */
-+#define DUK_STRIDX_TRUE                                               325                            /* 'true' */
-+#define DUK_STRIDX_FALSE                                              326                            /* 'false' */
-+#define DUK_STRIDX_IMPLEMENTS                                         327                            /* 'implements' */
-+#define DUK_STRIDX_INTERFACE                                          328                            /* 'interface' */
-+#define DUK_STRIDX_LET                                                329                            /* 'let' */
-+#define DUK_STRIDX_PACKAGE                                            330                            /* 'package' */
-+#define DUK_STRIDX_PRIVATE                                            331                            /* 'private' */
-+#define DUK_STRIDX_PROTECTED                                          332                            /* 'protected' */
-+#define DUK_STRIDX_PUBLIC                                             333                            /* 'public' */
-+#define DUK_STRIDX_STATIC                                             334                            /* 'static' */
-+#define DUK_STRIDX_YIELD                                              335                            /* 'yield' */
-+
-+#define DUK_HEAP_STRING_UC_LOGGER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER)
-+#define DUK_HTHREAD_STRING_UC_LOGGER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER)
-+#define DUK_HEAP_STRING_UC_THREAD(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD)
-+#define DUK_HTHREAD_STRING_UC_THREAD(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD)
-+#define DUK_HEAP_STRING_UC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER)
-+#define DUK_HTHREAD_STRING_UC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER)
-+#define DUK_HEAP_STRING_UC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER)
-+#define DUK_HTHREAD_STRING_UC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER)
-+#define DUK_HEAP_STRING_DEC_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV)
-+#define DUK_HTHREAD_STRING_DEC_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV)
-+#define DUK_HEAP_STRING_OBJ_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV)
-+#define DUK_HTHREAD_STRING_OBJ_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV)
-+#define DUK_HEAP_STRING_EMPTY_STRING(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING)
-+#define DUK_HTHREAD_STRING_EMPTY_STRING(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING)
-+#define DUK_HEAP_STRING_GLOBAL(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL)
-+#define DUK_HTHREAD_STRING_GLOBAL(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL)
-+#define DUK_HEAP_STRING_UC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS)
-+#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS)
-+#define DUK_HEAP_STRING_JSON(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON)
-+#define DUK_HTHREAD_STRING_JSON(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON)
-+#define DUK_HEAP_STRING_MATH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH)
-+#define DUK_HTHREAD_STRING_MATH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH)
-+#define DUK_HEAP_STRING_UC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR)
-+#define DUK_HTHREAD_STRING_UC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR)
-+#define DUK_HEAP_STRING_REG_EXP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP)
-+#define DUK_HTHREAD_STRING_REG_EXP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP)
-+#define DUK_HEAP_STRING_DATE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE)
-+#define DUK_HTHREAD_STRING_DATE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE)
-+#define DUK_HEAP_STRING_UC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER)
-+#define DUK_HTHREAD_STRING_UC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER)
-+#define DUK_HEAP_STRING_UC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN)
-+#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN)
-+#define DUK_HEAP_STRING_UC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING)
-+#define DUK_HTHREAD_STRING_UC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING)
-+#define DUK_HEAP_STRING_ARRAY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY)
-+#define DUK_HTHREAD_STRING_ARRAY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY)
-+#define DUK_HEAP_STRING_UC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION)
-+#define DUK_HTHREAD_STRING_UC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION)
-+#define DUK_HEAP_STRING_UC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT)
-+#define DUK_HTHREAD_STRING_UC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT)
-+#define DUK_HEAP_STRING_UC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL)
-+#define DUK_HTHREAD_STRING_UC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL)
-+#define DUK_HEAP_STRING_UC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED)
-+#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED)
-+#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2)
-+#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2)
-+#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1)
-+#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1)
-+#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF)
-+#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF)
-+#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF)
-+#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF)
-+#define DUK_HEAP_STRING_JSON_EXT_NAN(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN)
-+#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN)
-+#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED)
-+#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED)
-+#define DUK_HEAP_STRING_TO_LOG_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING)
-+#define DUK_HEAP_STRING_CLOG(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG)
-+#define DUK_HTHREAD_STRING_CLOG(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG)
-+#define DUK_HEAP_STRING_LC_L(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L)
-+#define DUK_HTHREAD_STRING_LC_L(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L)
-+#define DUK_HEAP_STRING_LC_N(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N)
-+#define DUK_HTHREAD_STRING_LC_N(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N)
-+#define DUK_HEAP_STRING_LC_FATAL(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL)
-+#define DUK_HTHREAD_STRING_LC_FATAL(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL)
-+#define DUK_HEAP_STRING_LC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR)
-+#define DUK_HTHREAD_STRING_LC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR)
-+#define DUK_HEAP_STRING_LC_WARN(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN)
-+#define DUK_HTHREAD_STRING_LC_WARN(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN)
-+#define DUK_HEAP_STRING_LC_DEBUG(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG)
-+#define DUK_HTHREAD_STRING_LC_DEBUG(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG)
-+#define DUK_HEAP_STRING_LC_TRACE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE)
-+#define DUK_HTHREAD_STRING_LC_TRACE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE)
-+#define DUK_HEAP_STRING_RAW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW)
-+#define DUK_HTHREAD_STRING_RAW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW)
-+#define DUK_HEAP_STRING_FMT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT)
-+#define DUK_HTHREAD_STRING_FMT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT)
-+#define DUK_HEAP_STRING_CURRENT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT)
-+#define DUK_HTHREAD_STRING_CURRENT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT)
-+#define DUK_HEAP_STRING_RESUME(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME)
-+#define DUK_HTHREAD_STRING_RESUME(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME)
-+#define DUK_HEAP_STRING_COMPACT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT)
-+#define DUK_HTHREAD_STRING_COMPACT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT)
-+#define DUK_HEAP_STRING_JC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC)
-+#define DUK_HTHREAD_STRING_JC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC)
-+#define DUK_HEAP_STRING_JX(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX)
-+#define DUK_HTHREAD_STRING_JX(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX)
-+#define DUK_HEAP_STRING_BASE64(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64)
-+#define DUK_HTHREAD_STRING_BASE64(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64)
-+#define DUK_HEAP_STRING_HEX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX)
-+#define DUK_HTHREAD_STRING_HEX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX)
-+#define DUK_HEAP_STRING_DEC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC)
-+#define DUK_HTHREAD_STRING_DEC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC)
-+#define DUK_HEAP_STRING_ENC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC)
-+#define DUK_HTHREAD_STRING_ENC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC)
-+#define DUK_HEAP_STRING_FIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN)
-+#define DUK_HTHREAD_STRING_FIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN)
-+#define DUK_HEAP_STRING_GC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC)
-+#define DUK_HTHREAD_STRING_GC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC)
-+#define DUK_HEAP_STRING_ACT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT)
-+#define DUK_HTHREAD_STRING_ACT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT)
-+#define DUK_HEAP_STRING_LC_INFO(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO)
-+#define DUK_HTHREAD_STRING_LC_INFO(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO)
-+#define DUK_HEAP_STRING_VERSION(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION)
-+#define DUK_HTHREAD_STRING_VERSION(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION)
-+#define DUK_HEAP_STRING_ENV(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV)
-+#define DUK_HTHREAD_STRING_ENV(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV)
-+#define DUK_HEAP_STRING_MOD_LOADED(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED)
-+#define DUK_HTHREAD_STRING_MOD_LOADED(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED)
-+#define DUK_HEAP_STRING_MOD_SEARCH(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH)
-+#define DUK_HTHREAD_STRING_MOD_SEARCH(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH)
-+#define DUK_HEAP_STRING_ERR_THROW(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW)
-+#define DUK_HTHREAD_STRING_ERR_THROW(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW)
-+#define DUK_HEAP_STRING_ERR_CREATE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE)
-+#define DUK_HTHREAD_STRING_ERR_CREATE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE)
-+#define DUK_HEAP_STRING_COMPILE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE)
-+#define DUK_HTHREAD_STRING_COMPILE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE)
-+#define DUK_HEAP_STRING_INT_REGBASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE)
-+#define DUK_HTHREAD_STRING_INT_REGBASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE)
-+#define DUK_HEAP_STRING_INT_THREAD(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD)
-+#define DUK_HTHREAD_STRING_INT_THREAD(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD)
-+#define DUK_HEAP_STRING_INT_HANDLER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER)
-+#define DUK_HTHREAD_STRING_INT_HANDLER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER)
-+#define DUK_HEAP_STRING_INT_FINALIZER(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER)
-+#define DUK_HTHREAD_STRING_INT_FINALIZER(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER)
-+#define DUK_HEAP_STRING_INT_CALLEE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE)
-+#define DUK_HTHREAD_STRING_INT_CALLEE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE)
-+#define DUK_HEAP_STRING_INT_MAP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP)
-+#define DUK_HTHREAD_STRING_INT_MAP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP)
-+#define DUK_HEAP_STRING_INT_ARGS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS)
-+#define DUK_HTHREAD_STRING_INT_ARGS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS)
-+#define DUK_HEAP_STRING_INT_THIS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS)
-+#define DUK_HTHREAD_STRING_INT_THIS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS)
-+#define DUK_HEAP_STRING_INT_PC2LINE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE)
-+#define DUK_HTHREAD_STRING_INT_PC2LINE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE)
-+#define DUK_HEAP_STRING_INT_SOURCE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE)
-+#define DUK_HTHREAD_STRING_INT_SOURCE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE)
-+#define DUK_HEAP_STRING_INT_VARENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV)
-+#define DUK_HTHREAD_STRING_INT_VARENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV)
-+#define DUK_HEAP_STRING_INT_LEXENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV)
-+#define DUK_HTHREAD_STRING_INT_LEXENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV)
-+#define DUK_HEAP_STRING_INT_VARMAP(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP)
-+#define DUK_HTHREAD_STRING_INT_VARMAP(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP)
-+#define DUK_HEAP_STRING_INT_FORMALS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS)
-+#define DUK_HTHREAD_STRING_INT_FORMALS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS)
-+#define DUK_HEAP_STRING_INT_BYTECODE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE)
-+#define DUK_HTHREAD_STRING_INT_BYTECODE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE)
-+#define DUK_HEAP_STRING_INT_NEXT(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT)
-+#define DUK_HTHREAD_STRING_INT_NEXT(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT)
-+#define DUK_HEAP_STRING_INT_TARGET(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET)
-+#define DUK_HTHREAD_STRING_INT_TARGET(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET)
-+#define DUK_HEAP_STRING_INT_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE)
-+#define DUK_HTHREAD_STRING_INT_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE)
-+#define DUK_HEAP_STRING_LC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER)
-+#define DUK_HTHREAD_STRING_LC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER)
-+#define DUK_HEAP_STRING_LC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER)
-+#define DUK_HTHREAD_STRING_LC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER)
-+#define DUK_HEAP_STRING_INT_TRACEDATA(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA)
-+#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA)
-+#define DUK_HEAP_STRING_LINE_NUMBER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER)
-+#define DUK_HTHREAD_STRING_LINE_NUMBER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER)
-+#define DUK_HEAP_STRING_FILE_NAME(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME)
-+#define DUK_HTHREAD_STRING_FILE_NAME(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME)
-+#define DUK_HEAP_STRING_PC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC)
-+#define DUK_HTHREAD_STRING_PC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC)
-+#define DUK_HEAP_STRING_STACK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK)
-+#define DUK_HTHREAD_STRING_STACK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK)
-+#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR)
-+#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR)
-+#define DUK_HEAP_STRING_DUKTAPE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE)
-+#define DUK_HTHREAD_STRING_DUKTAPE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE)
-+#define DUK_HEAP_STRING_ID(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID)
-+#define DUK_HTHREAD_STRING_ID(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID)
-+#define DUK_HEAP_STRING_REQUIRE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE)
-+#define DUK_HTHREAD_STRING_REQUIRE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE)
-+#define DUK_HEAP_STRING___PROTO__(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__)
-+#define DUK_HTHREAD_STRING___PROTO__(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__)
-+#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_OWN_KEYS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS)
-+#define DUK_HTHREAD_STRING_OWN_KEYS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS)
-+#define DUK_HEAP_STRING_ENUMERATE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE)
-+#define DUK_HTHREAD_STRING_ENUMERATE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE)
-+#define DUK_HEAP_STRING_DELETE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY)
-+#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY)
-+#define DUK_HEAP_STRING_HAS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS)
-+#define DUK_HTHREAD_STRING_HAS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS)
-+#define DUK_HEAP_STRING_PROXY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY)
-+#define DUK_HTHREAD_STRING_PROXY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY)
-+#define DUK_HEAP_STRING_CALLEE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE)
-+#define DUK_HTHREAD_STRING_CALLEE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE)
-+#define DUK_HEAP_STRING_INVALID_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE)
-+#define DUK_HTHREAD_STRING_INVALID_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE)
-+#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS)
-+#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS)
-+#define DUK_HEAP_STRING_NEWLINE_TAB(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB)
-+#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB)
-+#define DUK_HEAP_STRING_SPACE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE)
-+#define DUK_HTHREAD_STRING_SPACE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE)
-+#define DUK_HEAP_STRING_COMMA(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA)
-+#define DUK_HTHREAD_STRING_COMMA(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA)
-+#define DUK_HEAP_STRING_MINUS_ZERO(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO)
-+#define DUK_HTHREAD_STRING_MINUS_ZERO(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO)
-+#define DUK_HEAP_STRING_PLUS_ZERO(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO)
-+#define DUK_HTHREAD_STRING_PLUS_ZERO(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO)
-+#define DUK_HEAP_STRING_ZERO(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO)
-+#define DUK_HTHREAD_STRING_ZERO(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO)
-+#define DUK_HEAP_STRING_MINUS_INFINITY(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY)
-+#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY)
-+#define DUK_HEAP_STRING_PLUS_INFINITY(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY)
-+#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY)
-+#define DUK_HEAP_STRING_INFINITY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY)
-+#define DUK_HTHREAD_STRING_INFINITY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY)
-+#define DUK_HEAP_STRING_LC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT)
-+#define DUK_HTHREAD_STRING_LC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT)
-+#define DUK_HEAP_STRING_LC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING)
-+#define DUK_HTHREAD_STRING_LC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING)
-+#define DUK_HEAP_STRING_LC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER)
-+#define DUK_HTHREAD_STRING_LC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER)
-+#define DUK_HEAP_STRING_LC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN)
-+#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN)
-+#define DUK_HEAP_STRING_LC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED)
-+#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED)
-+#define DUK_HEAP_STRING_STRINGIFY(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY)
-+#define DUK_HTHREAD_STRING_STRINGIFY(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY)
-+#define DUK_HEAP_STRING_TAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN)
-+#define DUK_HTHREAD_STRING_TAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN)
-+#define DUK_HEAP_STRING_SQRT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT)
-+#define DUK_HTHREAD_STRING_SQRT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT)
-+#define DUK_HEAP_STRING_SIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN)
-+#define DUK_HTHREAD_STRING_SIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN)
-+#define DUK_HEAP_STRING_ROUND(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND)
-+#define DUK_HTHREAD_STRING_ROUND(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND)
-+#define DUK_HEAP_STRING_RANDOM(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM)
-+#define DUK_HTHREAD_STRING_RANDOM(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM)
-+#define DUK_HEAP_STRING_POW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW)
-+#define DUK_HTHREAD_STRING_POW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW)
-+#define DUK_HEAP_STRING_MIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN)
-+#define DUK_HTHREAD_STRING_MIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN)
-+#define DUK_HEAP_STRING_MAX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX)
-+#define DUK_HTHREAD_STRING_MAX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX)
-+#define DUK_HEAP_STRING_LOG(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG)
-+#define DUK_HTHREAD_STRING_LOG(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG)
-+#define DUK_HEAP_STRING_FLOOR(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR)
-+#define DUK_HTHREAD_STRING_FLOOR(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR)
-+#define DUK_HEAP_STRING_EXP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP)
-+#define DUK_HTHREAD_STRING_EXP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP)
-+#define DUK_HEAP_STRING_COS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS)
-+#define DUK_HTHREAD_STRING_COS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS)
-+#define DUK_HEAP_STRING_CEIL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL)
-+#define DUK_HTHREAD_STRING_CEIL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL)
-+#define DUK_HEAP_STRING_ATAN2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2)
-+#define DUK_HTHREAD_STRING_ATAN2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2)
-+#define DUK_HEAP_STRING_ATAN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN)
-+#define DUK_HTHREAD_STRING_ATAN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN)
-+#define DUK_HEAP_STRING_ASIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN)
-+#define DUK_HTHREAD_STRING_ASIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN)
-+#define DUK_HEAP_STRING_ACOS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS)
-+#define DUK_HTHREAD_STRING_ACOS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS)
-+#define DUK_HEAP_STRING_ABS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS)
-+#define DUK_HTHREAD_STRING_ABS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS)
-+#define DUK_HEAP_STRING_SQRT2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2)
-+#define DUK_HTHREAD_STRING_SQRT2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2)
-+#define DUK_HEAP_STRING_SQRT1_2(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2)
-+#define DUK_HTHREAD_STRING_SQRT1_2(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2)
-+#define DUK_HEAP_STRING_PI(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI)
-+#define DUK_HTHREAD_STRING_PI(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI)
-+#define DUK_HEAP_STRING_LOG10E(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E)
-+#define DUK_HTHREAD_STRING_LOG10E(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E)
-+#define DUK_HEAP_STRING_LOG2E(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E)
-+#define DUK_HTHREAD_STRING_LOG2E(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E)
-+#define DUK_HEAP_STRING_LN2(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2)
-+#define DUK_HTHREAD_STRING_LN2(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2)
-+#define DUK_HEAP_STRING_LN10(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10)
-+#define DUK_HTHREAD_STRING_LN10(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10)
-+#define DUK_HEAP_STRING_E(heap)                                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E)
-+#define DUK_HTHREAD_STRING_E(thr)                                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E)
-+#define DUK_HEAP_STRING_MESSAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE)
-+#define DUK_HTHREAD_STRING_MESSAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE)
-+#define DUK_HEAP_STRING_NAME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME)
-+#define DUK_HTHREAD_STRING_NAME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME)
-+#define DUK_HEAP_STRING_INPUT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT)
-+#define DUK_HTHREAD_STRING_INPUT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT)
-+#define DUK_HEAP_STRING_INDEX(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX)
-+#define DUK_HTHREAD_STRING_INDEX(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX)
-+#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
-+#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
-+#define DUK_HEAP_STRING_LAST_INDEX(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX)
-+#define DUK_HTHREAD_STRING_LAST_INDEX(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX)
-+#define DUK_HEAP_STRING_MULTILINE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE)
-+#define DUK_HTHREAD_STRING_MULTILINE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE)
-+#define DUK_HEAP_STRING_IGNORE_CASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE)
-+#define DUK_HTHREAD_STRING_IGNORE_CASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE)
-+#define DUK_HEAP_STRING_SOURCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE)
-+#define DUK_HTHREAD_STRING_SOURCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE)
-+#define DUK_HEAP_STRING_TEST(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST)
-+#define DUK_HTHREAD_STRING_TEST(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST)
-+#define DUK_HEAP_STRING_EXEC(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC)
-+#define DUK_HTHREAD_STRING_EXEC(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC)
-+#define DUK_HEAP_STRING_TO_GMT_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING)
-+#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING)
-+#define DUK_HEAP_STRING_SET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR)
-+#define DUK_HTHREAD_STRING_SET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR)
-+#define DUK_HEAP_STRING_GET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR)
-+#define DUK_HTHREAD_STRING_GET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR)
-+#define DUK_HEAP_STRING_TO_JSON(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON)
-+#define DUK_HTHREAD_STRING_TO_JSON(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON)
-+#define DUK_HEAP_STRING_TO_ISO_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING)
-+#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING)
-+#define DUK_HEAP_STRING_TO_UTC_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING)
-+#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING)
-+#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR)
-+#define DUK_HEAP_STRING_SET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR)
-+#define DUK_HEAP_STRING_SET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH)
-+#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH)
-+#define DUK_HEAP_STRING_SET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH)
-+#define DUK_HTHREAD_STRING_SET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH)
-+#define DUK_HEAP_STRING_SET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE)
-+#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE)
-+#define DUK_HEAP_STRING_SET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE)
-+#define DUK_HTHREAD_STRING_SET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE)
-+#define DUK_HEAP_STRING_SET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS)
-+#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS)
-+#define DUK_HEAP_STRING_SET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS)
-+#define DUK_HTHREAD_STRING_SET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS)
-+#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES)
-+#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES)
-+#define DUK_HEAP_STRING_SET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES)
-+#define DUK_HTHREAD_STRING_SET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES)
-+#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS)
-+#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS)
-+#define DUK_HEAP_STRING_SET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS)
-+#define DUK_HTHREAD_STRING_SET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS)
-+#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS)
-+#define DUK_HEAP_STRING_SET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS)
-+#define DUK_HEAP_STRING_SET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME)
-+#define DUK_HTHREAD_STRING_SET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME)
-+#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap)                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET)
-+#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr)                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET)
-+#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS)
-+#define DUK_HEAP_STRING_GET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS)
-+#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS)
-+#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS)
-+#define DUK_HEAP_STRING_GET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS)
-+#define DUK_HTHREAD_STRING_GET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS)
-+#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES)
-+#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES)
-+#define DUK_HEAP_STRING_GET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES)
-+#define DUK_HTHREAD_STRING_GET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES)
-+#define DUK_HEAP_STRING_GET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS)
-+#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS)
-+#define DUK_HEAP_STRING_GET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS)
-+#define DUK_HTHREAD_STRING_GET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS)
-+#define DUK_HEAP_STRING_GET_UTC_DAY(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY)
-+#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY)
-+#define DUK_HEAP_STRING_GET_DAY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY)
-+#define DUK_HTHREAD_STRING_GET_DAY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY)
-+#define DUK_HEAP_STRING_GET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE)
-+#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE)
-+#define DUK_HEAP_STRING_GET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE)
-+#define DUK_HTHREAD_STRING_GET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE)
-+#define DUK_HEAP_STRING_GET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH)
-+#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH)
-+#define DUK_HEAP_STRING_GET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH)
-+#define DUK_HTHREAD_STRING_GET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH)
-+#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR)
-+#define DUK_HEAP_STRING_GET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR)
-+#define DUK_HEAP_STRING_GET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME)
-+#define DUK_HTHREAD_STRING_GET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME)
-+#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING)
-+#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING)
-+#define DUK_HEAP_STRING_TO_TIME_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING)
-+#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING)
-+#define DUK_HEAP_STRING_TO_DATE_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING)
-+#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING)
-+#define DUK_HEAP_STRING_NOW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW)
-+#define DUK_HTHREAD_STRING_NOW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW)
-+#define DUK_HEAP_STRING_UTC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC)
-+#define DUK_HTHREAD_STRING_UTC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC)
-+#define DUK_HEAP_STRING_PARSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE)
-+#define DUK_HTHREAD_STRING_PARSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE)
-+#define DUK_HEAP_STRING_TO_PRECISION(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION)
-+#define DUK_HTHREAD_STRING_TO_PRECISION(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION)
-+#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL)
-+#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL)
-+#define DUK_HEAP_STRING_TO_FIXED(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED)
-+#define DUK_HTHREAD_STRING_TO_FIXED(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED)
-+#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY)
-+#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY)
-+#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY)
-+#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY)
-+#define DUK_HEAP_STRING_NAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN)
-+#define DUK_HTHREAD_STRING_NAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN)
-+#define DUK_HEAP_STRING_MIN_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE)
-+#define DUK_HTHREAD_STRING_MIN_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE)
-+#define DUK_HEAP_STRING_MAX_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE)
-+#define DUK_HTHREAD_STRING_MAX_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE)
-+#define DUK_HEAP_STRING_SUBSTR(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR)
-+#define DUK_HTHREAD_STRING_SUBSTR(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR)
-+#define DUK_HEAP_STRING_TRIM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM)
-+#define DUK_HTHREAD_STRING_TRIM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM)
-+#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
-+#define DUK_HEAP_STRING_TO_UPPER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE)
-+#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE)
-+#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
-+#define DUK_HEAP_STRING_TO_LOWER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE)
-+#define DUK_HEAP_STRING_SUBSTRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING)
-+#define DUK_HTHREAD_STRING_SUBSTRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING)
-+#define DUK_HEAP_STRING_SPLIT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT)
-+#define DUK_HTHREAD_STRING_SPLIT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT)
-+#define DUK_HEAP_STRING_SEARCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH)
-+#define DUK_HTHREAD_STRING_SEARCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH)
-+#define DUK_HEAP_STRING_REPLACE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE)
-+#define DUK_HTHREAD_STRING_REPLACE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE)
-+#define DUK_HEAP_STRING_MATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH)
-+#define DUK_HTHREAD_STRING_MATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH)
-+#define DUK_HEAP_STRING_LOCALE_COMPARE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE)
-+#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE)
-+#define DUK_HEAP_STRING_CHAR_CODE_AT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT)
-+#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT)
-+#define DUK_HEAP_STRING_CHAR_AT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT)
-+#define DUK_HTHREAD_STRING_CHAR_AT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT)
-+#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE)
-+#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE)
-+#define DUK_HEAP_STRING_REDUCE_RIGHT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT)
-+#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT)
-+#define DUK_HEAP_STRING_REDUCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE)
-+#define DUK_HTHREAD_STRING_REDUCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE)
-+#define DUK_HEAP_STRING_FILTER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER)
-+#define DUK_HTHREAD_STRING_FILTER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER)
-+#define DUK_HEAP_STRING_MAP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP)
-+#define DUK_HTHREAD_STRING_MAP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP)
-+#define DUK_HEAP_STRING_FOR_EACH(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH)
-+#define DUK_HTHREAD_STRING_FOR_EACH(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH)
-+#define DUK_HEAP_STRING_SOME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME)
-+#define DUK_HTHREAD_STRING_SOME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME)
-+#define DUK_HEAP_STRING_EVERY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY)
-+#define DUK_HTHREAD_STRING_EVERY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY)
-+#define DUK_HEAP_STRING_LAST_INDEX_OF(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF)
-+#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF)
-+#define DUK_HEAP_STRING_INDEX_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF)
-+#define DUK_HTHREAD_STRING_INDEX_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF)
-+#define DUK_HEAP_STRING_UNSHIFT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT)
-+#define DUK_HTHREAD_STRING_UNSHIFT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT)
-+#define DUK_HEAP_STRING_SPLICE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE)
-+#define DUK_HTHREAD_STRING_SPLICE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE)
-+#define DUK_HEAP_STRING_SORT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT)
-+#define DUK_HTHREAD_STRING_SORT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT)
-+#define DUK_HEAP_STRING_SLICE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE)
-+#define DUK_HTHREAD_STRING_SLICE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE)
-+#define DUK_HEAP_STRING_SHIFT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT)
-+#define DUK_HTHREAD_STRING_SHIFT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT)
-+#define DUK_HEAP_STRING_REVERSE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE)
-+#define DUK_HTHREAD_STRING_REVERSE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE)
-+#define DUK_HEAP_STRING_PUSH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH)
-+#define DUK_HTHREAD_STRING_PUSH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH)
-+#define DUK_HEAP_STRING_POP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP)
-+#define DUK_HTHREAD_STRING_POP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP)
-+#define DUK_HEAP_STRING_JOIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN)
-+#define DUK_HTHREAD_STRING_JOIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN)
-+#define DUK_HEAP_STRING_CONCAT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT)
-+#define DUK_HTHREAD_STRING_CONCAT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT)
-+#define DUK_HEAP_STRING_IS_ARRAY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY)
-+#define DUK_HTHREAD_STRING_IS_ARRAY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY)
-+#define DUK_HEAP_STRING_LC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS)
-+#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)
-+#define DUK_HEAP_STRING_CALLER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER)
-+#define DUK_HTHREAD_STRING_CALLER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER)
-+#define DUK_HEAP_STRING_BIND(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND)
-+#define DUK_HTHREAD_STRING_BIND(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND)
-+#define DUK_HEAP_STRING_CALL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL)
-+#define DUK_HTHREAD_STRING_CALL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL)
-+#define DUK_HEAP_STRING_APPLY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY)
-+#define DUK_HTHREAD_STRING_APPLY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY)
-+#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
-+#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
-+#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY)
-+#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY)
-+#define DUK_HEAP_STRING_VALUE_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF)
-+#define DUK_HTHREAD_STRING_VALUE_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF)
-+#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING)
-+#define DUK_HEAP_STRING_TO_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING)
-+#define DUK_HTHREAD_STRING_TO_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING)
-+#define DUK_HEAP_STRING_CONSTRUCTOR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR)
-+#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR)
-+#define DUK_HEAP_STRING_SET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET)
-+#define DUK_HTHREAD_STRING_SET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET)
-+#define DUK_HEAP_STRING_GET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET)
-+#define DUK_HTHREAD_STRING_GET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET)
-+#define DUK_HEAP_STRING_ENUMERABLE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE)
-+#define DUK_HTHREAD_STRING_ENUMERABLE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE)
-+#define DUK_HEAP_STRING_CONFIGURABLE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE)
-+#define DUK_HTHREAD_STRING_CONFIGURABLE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE)
-+#define DUK_HEAP_STRING_WRITABLE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE)
-+#define DUK_HTHREAD_STRING_WRITABLE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE)
-+#define DUK_HEAP_STRING_VALUE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE)
-+#define DUK_HTHREAD_STRING_VALUE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE)
-+#define DUK_HEAP_STRING_KEYS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS)
-+#define DUK_HTHREAD_STRING_KEYS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS)
-+#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE)
-+#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE)
-+#define DUK_HEAP_STRING_IS_FROZEN(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN)
-+#define DUK_HTHREAD_STRING_IS_FROZEN(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN)
-+#define DUK_HEAP_STRING_IS_SEALED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED)
-+#define DUK_HTHREAD_STRING_IS_SEALED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED)
-+#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS)
-+#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS)
-+#define DUK_HEAP_STRING_FREEZE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE)
-+#define DUK_HTHREAD_STRING_FREEZE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE)
-+#define DUK_HEAP_STRING_SEAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL)
-+#define DUK_HTHREAD_STRING_SEAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL)
-+#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES)
-+#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES)
-+#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY)
-+#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY)
-+#define DUK_HEAP_STRING_CREATE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE)
-+#define DUK_HTHREAD_STRING_CREATE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE)
-+#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
-+#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
-+#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap)             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
-+#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr)           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
-+#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_PROTOTYPE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE)
-+#define DUK_HTHREAD_STRING_PROTOTYPE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE)
-+#define DUK_HEAP_STRING_LENGTH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH)
-+#define DUK_HTHREAD_STRING_LENGTH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)
-+#define DUK_HEAP_STRING_ALERT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT)
-+#define DUK_HTHREAD_STRING_ALERT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT)
-+#define DUK_HEAP_STRING_PRINT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT)
-+#define DUK_HTHREAD_STRING_PRINT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT)
-+#define DUK_HEAP_STRING_UNESCAPE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE)
-+#define DUK_HTHREAD_STRING_UNESCAPE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE)
-+#define DUK_HEAP_STRING_ESCAPE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE)
-+#define DUK_HTHREAD_STRING_ESCAPE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE)
-+#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT)
-+#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT)
-+#define DUK_HEAP_STRING_ENCODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI)
-+#define DUK_HTHREAD_STRING_ENCODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI)
-+#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT)
-+#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT)
-+#define DUK_HEAP_STRING_DECODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI)
-+#define DUK_HTHREAD_STRING_DECODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI)
-+#define DUK_HEAP_STRING_IS_FINITE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE)
-+#define DUK_HTHREAD_STRING_IS_FINITE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE)
-+#define DUK_HEAP_STRING_IS_NAN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN)
-+#define DUK_HTHREAD_STRING_IS_NAN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN)
-+#define DUK_HEAP_STRING_PARSE_FLOAT(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT)
-+#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT)
-+#define DUK_HEAP_STRING_PARSE_INT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT)
-+#define DUK_HTHREAD_STRING_PARSE_INT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT)
-+#define DUK_HEAP_STRING_EVAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL)
-+#define DUK_HTHREAD_STRING_EVAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL)
-+#define DUK_HEAP_STRING_URI_ERROR(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR)
-+#define DUK_HTHREAD_STRING_URI_ERROR(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR)
-+#define DUK_HEAP_STRING_TYPE_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR)
-+#define DUK_HTHREAD_STRING_TYPE_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR)
-+#define DUK_HEAP_STRING_SYNTAX_ERROR(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR)
-+#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR)
-+#define DUK_HEAP_STRING_REFERENCE_ERROR(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR)
-+#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR)
-+#define DUK_HEAP_STRING_RANGE_ERROR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR)
-+#define DUK_HTHREAD_STRING_RANGE_ERROR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR)
-+#define DUK_HEAP_STRING_EVAL_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR)
-+#define DUK_HTHREAD_STRING_EVAL_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR)
-+#define DUK_HEAP_STRING_BREAK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK)
-+#define DUK_HTHREAD_STRING_BREAK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK)
-+#define DUK_HEAP_STRING_CASE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE)
-+#define DUK_HTHREAD_STRING_CASE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE)
-+#define DUK_HEAP_STRING_CATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH)
-+#define DUK_HTHREAD_STRING_CATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH)
-+#define DUK_HEAP_STRING_CONTINUE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE)
-+#define DUK_HTHREAD_STRING_CONTINUE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE)
-+#define DUK_HEAP_STRING_DEBUGGER(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER)
-+#define DUK_HTHREAD_STRING_DEBUGGER(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER)
-+#define DUK_HEAP_STRING_DEFAULT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT)
-+#define DUK_HTHREAD_STRING_DEFAULT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT)
-+#define DUK_HEAP_STRING_DELETE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE)
-+#define DUK_HTHREAD_STRING_DELETE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE)
-+#define DUK_HEAP_STRING_DO(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO)
-+#define DUK_HTHREAD_STRING_DO(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO)
-+#define DUK_HEAP_STRING_ELSE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE)
-+#define DUK_HTHREAD_STRING_ELSE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE)
-+#define DUK_HEAP_STRING_FINALLY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY)
-+#define DUK_HTHREAD_STRING_FINALLY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY)
-+#define DUK_HEAP_STRING_FOR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR)
-+#define DUK_HTHREAD_STRING_FOR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR)
-+#define DUK_HEAP_STRING_LC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION)
-+#define DUK_HTHREAD_STRING_LC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION)
-+#define DUK_HEAP_STRING_IF(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF)
-+#define DUK_HTHREAD_STRING_IF(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF)
-+#define DUK_HEAP_STRING_IN(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN)
-+#define DUK_HTHREAD_STRING_IN(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN)
-+#define DUK_HEAP_STRING_INSTANCEOF(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF)
-+#define DUK_HTHREAD_STRING_INSTANCEOF(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF)
-+#define DUK_HEAP_STRING_NEW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW)
-+#define DUK_HTHREAD_STRING_NEW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW)
-+#define DUK_HEAP_STRING_RETURN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN)
-+#define DUK_HTHREAD_STRING_RETURN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN)
-+#define DUK_HEAP_STRING_SWITCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH)
-+#define DUK_HTHREAD_STRING_SWITCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH)
-+#define DUK_HEAP_STRING_THIS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS)
-+#define DUK_HTHREAD_STRING_THIS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS)
-+#define DUK_HEAP_STRING_THROW(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW)
-+#define DUK_HTHREAD_STRING_THROW(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW)
-+#define DUK_HEAP_STRING_TRY(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY)
-+#define DUK_HTHREAD_STRING_TRY(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY)
-+#define DUK_HEAP_STRING_TYPEOF(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF)
-+#define DUK_HTHREAD_STRING_TYPEOF(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF)
-+#define DUK_HEAP_STRING_VAR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR)
-+#define DUK_HTHREAD_STRING_VAR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR)
-+#define DUK_HEAP_STRING_VOID(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID)
-+#define DUK_HTHREAD_STRING_VOID(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID)
-+#define DUK_HEAP_STRING_WHILE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE)
-+#define DUK_HTHREAD_STRING_WHILE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE)
-+#define DUK_HEAP_STRING_WITH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH)
-+#define DUK_HTHREAD_STRING_WITH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH)
-+#define DUK_HEAP_STRING_CLASS(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS)
-+#define DUK_HTHREAD_STRING_CLASS(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS)
-+#define DUK_HEAP_STRING_CONST(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST)
-+#define DUK_HTHREAD_STRING_CONST(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST)
-+#define DUK_HEAP_STRING_ENUM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM)
-+#define DUK_HTHREAD_STRING_ENUM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM)
-+#define DUK_HEAP_STRING_EXPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT)
-+#define DUK_HTHREAD_STRING_EXPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT)
-+#define DUK_HEAP_STRING_EXTENDS(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS)
-+#define DUK_HTHREAD_STRING_EXTENDS(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS)
-+#define DUK_HEAP_STRING_IMPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT)
-+#define DUK_HTHREAD_STRING_IMPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT)
-+#define DUK_HEAP_STRING_SUPER(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER)
-+#define DUK_HTHREAD_STRING_SUPER(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER)
-+#define DUK_HEAP_STRING_LC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL)
-+#define DUK_HTHREAD_STRING_LC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL)
-+#define DUK_HEAP_STRING_TRUE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE)
-+#define DUK_HTHREAD_STRING_TRUE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE)
-+#define DUK_HEAP_STRING_FALSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE)
-+#define DUK_HTHREAD_STRING_FALSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE)
-+#define DUK_HEAP_STRING_IMPLEMENTS(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS)
-+#define DUK_HTHREAD_STRING_IMPLEMENTS(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS)
-+#define DUK_HEAP_STRING_INTERFACE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE)
-+#define DUK_HTHREAD_STRING_INTERFACE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE)
-+#define DUK_HEAP_STRING_LET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET)
-+#define DUK_HTHREAD_STRING_LET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET)
-+#define DUK_HEAP_STRING_PACKAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE)
-+#define DUK_HTHREAD_STRING_PACKAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE)
-+#define DUK_HEAP_STRING_PRIVATE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE)
-+#define DUK_HTHREAD_STRING_PRIVATE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE)
-+#define DUK_HEAP_STRING_PROTECTED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED)
-+#define DUK_HTHREAD_STRING_PROTECTED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED)
-+#define DUK_HEAP_STRING_PUBLIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC)
-+#define DUK_HTHREAD_STRING_PUBLIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC)
-+#define DUK_HEAP_STRING_STATIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC)
-+#define DUK_HTHREAD_STRING_STATIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC)
-+#define DUK_HEAP_STRING_YIELD(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD)
-+#define DUK_HTHREAD_STRING_YIELD(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD)
-+
-+#define DUK_HEAP_NUM_STRINGS                                          336
-+
-+#define DUK_STRIDX_START_RESERVED                                     291
-+#define DUK_STRIDX_START_STRICT_RESERVED                              327
-+#define DUK_STRIDX_END_RESERVED                                       336                            /* exclusive endpoint */
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128];
-+DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341];
-+#ifdef DUK_USE_BUILTIN_INITJS
-+DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187];
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_BUILTINS_DATA_LENGTH                                      1341
-+#ifdef DUK_USE_BUILTIN_INITJS
-+#define DUK_BUILTIN_INITJS_DATA_LENGTH                                187
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+
-+#define DUK_BIDX_GLOBAL                                               0
-+#define DUK_BIDX_GLOBAL_ENV                                           1
-+#define DUK_BIDX_OBJECT_CONSTRUCTOR                                   2
-+#define DUK_BIDX_OBJECT_PROTOTYPE                                     3
-+#define DUK_BIDX_FUNCTION_CONSTRUCTOR                                 4
-+#define DUK_BIDX_FUNCTION_PROTOTYPE                                   5
-+#define DUK_BIDX_ARRAY_CONSTRUCTOR                                    6
-+#define DUK_BIDX_ARRAY_PROTOTYPE                                      7
-+#define DUK_BIDX_STRING_CONSTRUCTOR                                   8
-+#define DUK_BIDX_STRING_PROTOTYPE                                     9
-+#define DUK_BIDX_BOOLEAN_CONSTRUCTOR                                  10
-+#define DUK_BIDX_BOOLEAN_PROTOTYPE                                    11
-+#define DUK_BIDX_NUMBER_CONSTRUCTOR                                   12
-+#define DUK_BIDX_NUMBER_PROTOTYPE                                     13
-+#define DUK_BIDX_DATE_CONSTRUCTOR                                     14
-+#define DUK_BIDX_DATE_PROTOTYPE                                       15
-+#define DUK_BIDX_REGEXP_CONSTRUCTOR                                   16
-+#define DUK_BIDX_REGEXP_PROTOTYPE                                     17
-+#define DUK_BIDX_ERROR_CONSTRUCTOR                                    18
-+#define DUK_BIDX_ERROR_PROTOTYPE                                      19
-+#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR                               20
-+#define DUK_BIDX_EVAL_ERROR_PROTOTYPE                                 21
-+#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR                              22
-+#define DUK_BIDX_RANGE_ERROR_PROTOTYPE                                23
-+#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR                          24
-+#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE                            25
-+#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR                             26
-+#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE                               27
-+#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR                               28
-+#define DUK_BIDX_TYPE_ERROR_PROTOTYPE                                 29
-+#define DUK_BIDX_URI_ERROR_CONSTRUCTOR                                30
-+#define DUK_BIDX_URI_ERROR_PROTOTYPE                                  31
-+#define DUK_BIDX_MATH                                                 32
-+#define DUK_BIDX_JSON                                                 33
-+#define DUK_BIDX_TYPE_ERROR_THROWER                                   34
-+#define DUK_BIDX_PROXY_CONSTRUCTOR                                    35
-+#define DUK_BIDX_DUKTAPE                                              36
-+#define DUK_BIDX_THREAD_CONSTRUCTOR                                   37
-+#define DUK_BIDX_THREAD_PROTOTYPE                                     38
-+#define DUK_BIDX_BUFFER_CONSTRUCTOR                                   39
-+#define DUK_BIDX_BUFFER_PROTOTYPE                                     40
-+#define DUK_BIDX_POINTER_CONSTRUCTOR                                  41
-+#define DUK_BIDX_POINTER_PROTOTYPE                                    42
-+#define DUK_BIDX_LOGGER_CONSTRUCTOR                                   43
-+#define DUK_BIDX_LOGGER_PROTOTYPE                                     44
-+#define DUK_BIDX_DOUBLE_ERROR                                         45
-+
-+#define DUK_NUM_BUILTINS                                              46
-+
-+#elif defined(DUK_USE_DOUBLE_BE)
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943];
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STRDATA_DATA_LENGTH                                       1943
-+#define DUK_STRDATA_MAX_STRLEN                                        24
-+
-+#define DUK_STRIDX_UC_LOGGER                                          0                              /* 'Logger' */
-+#define DUK_STRIDX_UC_THREAD                                          1                              /* 'Thread' */
-+#define DUK_STRIDX_UC_POINTER                                         2                              /* 'Pointer' */
-+#define DUK_STRIDX_UC_BUFFER                                          3                              /* 'Buffer' */
-+#define DUK_STRIDX_DEC_ENV                                            4                              /* 'DecEnv' */
-+#define DUK_STRIDX_OBJ_ENV                                            5                              /* 'ObjEnv' */
-+#define DUK_STRIDX_EMPTY_STRING                                       6                              /* '' */
-+#define DUK_STRIDX_GLOBAL                                             7                              /* 'global' */
-+#define DUK_STRIDX_UC_ARGUMENTS                                       8                              /* 'Arguments' */
-+#define DUK_STRIDX_JSON                                               9                              /* 'JSON' */
-+#define DUK_STRIDX_MATH                                               10                             /* 'Math' */
-+#define DUK_STRIDX_UC_ERROR                                           11                             /* 'Error' */
-+#define DUK_STRIDX_REG_EXP                                            12                             /* 'RegExp' */
-+#define DUK_STRIDX_DATE                                               13                             /* 'Date' */
-+#define DUK_STRIDX_UC_NUMBER                                          14                             /* 'Number' */
-+#define DUK_STRIDX_UC_BOOLEAN                                         15                             /* 'Boolean' */
-+#define DUK_STRIDX_UC_STRING                                          16                             /* 'String' */
-+#define DUK_STRIDX_ARRAY                                              17                             /* 'Array' */
-+#define DUK_STRIDX_UC_FUNCTION                                        18                             /* 'Function' */
-+#define DUK_STRIDX_UC_OBJECT                                          19                             /* 'Object' */
-+#define DUK_STRIDX_UC_NULL                                            20                             /* 'Null' */
-+#define DUK_STRIDX_UC_UNDEFINED                                       21                             /* 'Undefined' */
-+#define DUK_STRIDX_JSON_EXT_FUNCTION2                                 22                             /* '{_func:true}' */
-+#define DUK_STRIDX_JSON_EXT_FUNCTION1                                 23                             /* '{"_func":true}' */
-+#define DUK_STRIDX_JSON_EXT_NEGINF                                    24                             /* '{"_ninf":true}' */
-+#define DUK_STRIDX_JSON_EXT_POSINF                                    25                             /* '{"_inf":true}' */
-+#define DUK_STRIDX_JSON_EXT_NAN                                       26                             /* '{"_nan":true}' */
-+#define DUK_STRIDX_JSON_EXT_UNDEFINED                                 27                             /* '{"_undef":true}' */
-+#define DUK_STRIDX_TO_LOG_STRING                                      28                             /* 'toLogString' */
-+#define DUK_STRIDX_CLOG                                               29                             /* 'clog' */
-+#define DUK_STRIDX_LC_L                                               30                             /* 'l' */
-+#define DUK_STRIDX_LC_N                                               31                             /* 'n' */
-+#define DUK_STRIDX_LC_FATAL                                           32                             /* 'fatal' */
-+#define DUK_STRIDX_LC_ERROR                                           33                             /* 'error' */
-+#define DUK_STRIDX_LC_WARN                                            34                             /* 'warn' */
-+#define DUK_STRIDX_LC_DEBUG                                           35                             /* 'debug' */
-+#define DUK_STRIDX_LC_TRACE                                           36                             /* 'trace' */
-+#define DUK_STRIDX_RAW                                                37                             /* 'raw' */
-+#define DUK_STRIDX_FMT                                                38                             /* 'fmt' */
-+#define DUK_STRIDX_CURRENT                                            39                             /* 'current' */
-+#define DUK_STRIDX_RESUME                                             40                             /* 'resume' */
-+#define DUK_STRIDX_COMPACT                                            41                             /* 'compact' */
-+#define DUK_STRIDX_JC                                                 42                             /* 'jc' */
-+#define DUK_STRIDX_JX                                                 43                             /* 'jx' */
-+#define DUK_STRIDX_BASE64                                             44                             /* 'base64' */
-+#define DUK_STRIDX_HEX                                                45                             /* 'hex' */
-+#define DUK_STRIDX_DEC                                                46                             /* 'dec' */
-+#define DUK_STRIDX_ENC                                                47                             /* 'enc' */
-+#define DUK_STRIDX_FIN                                                48                             /* 'fin' */
-+#define DUK_STRIDX_GC                                                 49                             /* 'gc' */
-+#define DUK_STRIDX_ACT                                                50                             /* 'act' */
-+#define DUK_STRIDX_LC_INFO                                            51                             /* 'info' */
-+#define DUK_STRIDX_VERSION                                            52                             /* 'version' */
-+#define DUK_STRIDX_ENV                                                53                             /* 'env' */
-+#define DUK_STRIDX_MOD_LOADED                                         54                             /* 'modLoaded' */
-+#define DUK_STRIDX_MOD_SEARCH                                         55                             /* 'modSearch' */
-+#define DUK_STRIDX_ERR_THROW                                          56                             /* 'errThrow' */
-+#define DUK_STRIDX_ERR_CREATE                                         57                             /* 'errCreate' */
-+#define DUK_STRIDX_COMPILE                                            58                             /* 'compile' */
-+#define DUK_STRIDX_INT_REGBASE                                        59                             /* '\x00Regbase' */
-+#define DUK_STRIDX_INT_THREAD                                         60                             /* '\x00Thread' */
-+#define DUK_STRIDX_INT_HANDLER                                        61                             /* '\x00Handler' */
-+#define DUK_STRIDX_INT_FINALIZER                                      62                             /* '\x00Finalizer' */
-+#define DUK_STRIDX_INT_CALLEE                                         63                             /* '\x00Callee' */
-+#define DUK_STRIDX_INT_MAP                                            64                             /* '\x00Map' */
-+#define DUK_STRIDX_INT_ARGS                                           65                             /* '\x00Args' */
-+#define DUK_STRIDX_INT_THIS                                           66                             /* '\x00This' */
-+#define DUK_STRIDX_INT_PC2LINE                                        67                             /* '\x00Pc2line' */
-+#define DUK_STRIDX_INT_SOURCE                                         68                             /* '\x00Source' */
-+#define DUK_STRIDX_INT_VARENV                                         69                             /* '\x00Varenv' */
-+#define DUK_STRIDX_INT_LEXENV                                         70                             /* '\x00Lexenv' */
-+#define DUK_STRIDX_INT_VARMAP                                         71                             /* '\x00Varmap' */
-+#define DUK_STRIDX_INT_FORMALS                                        72                             /* '\x00Formals' */
-+#define DUK_STRIDX_INT_BYTECODE                                       73                             /* '\x00Bytecode' */
-+#define DUK_STRIDX_INT_NEXT                                           74                             /* '\x00Next' */
-+#define DUK_STRIDX_INT_TARGET                                         75                             /* '\x00Target' */
-+#define DUK_STRIDX_INT_VALUE                                          76                             /* '\x00Value' */
-+#define DUK_STRIDX_LC_POINTER                                         77                             /* 'pointer' */
-+#define DUK_STRIDX_LC_BUFFER                                          78                             /* 'buffer' */
-+#define DUK_STRIDX_INT_TRACEDATA                                      79                             /* '\x00Tracedata' */
-+#define DUK_STRIDX_LINE_NUMBER                                        80                             /* 'lineNumber' */
-+#define DUK_STRIDX_FILE_NAME                                          81                             /* 'fileName' */
-+#define DUK_STRIDX_PC                                                 82                             /* 'pc' */
-+#define DUK_STRIDX_STACK                                              83                             /* 'stack' */
-+#define DUK_STRIDX_THROW_TYPE_ERROR                                   84                             /* 'ThrowTypeError' */
-+#define DUK_STRIDX_DUKTAPE                                            85                             /* 'Duktape' */
-+#define DUK_STRIDX_ID                                                 86                             /* 'id' */
-+#define DUK_STRIDX_REQUIRE                                            87                             /* 'require' */
-+#define DUK_STRIDX___PROTO__                                          88                             /* '__proto__' */
-+#define DUK_STRIDX_SET_PROTOTYPE_OF                                   89                             /* 'setPrototypeOf' */
-+#define DUK_STRIDX_OWN_KEYS                                           90                             /* 'ownKeys' */
-+#define DUK_STRIDX_ENUMERATE                                          91                             /* 'enumerate' */
-+#define DUK_STRIDX_DELETE_PROPERTY                                    92                             /* 'deleteProperty' */
-+#define DUK_STRIDX_HAS                                                93                             /* 'has' */
-+#define DUK_STRIDX_PROXY                                              94                             /* 'Proxy' */
-+#define DUK_STRIDX_CALLEE                                             95                             /* 'callee' */
-+#define DUK_STRIDX_INVALID_DATE                                       96                             /* 'Invalid Date' */
-+#define DUK_STRIDX_BRACKETED_ELLIPSIS                                 97                             /* '[...]' */
-+#define DUK_STRIDX_NEWLINE_TAB                                        98                             /* '\n\t' */
-+#define DUK_STRIDX_SPACE                                              99                             /* ' ' */
-+#define DUK_STRIDX_COMMA                                              100                            /* ',' */
-+#define DUK_STRIDX_MINUS_ZERO                                         101                            /* '-0' */
-+#define DUK_STRIDX_PLUS_ZERO                                          102                            /* '+0' */
-+#define DUK_STRIDX_ZERO                                               103                            /* '0' */
-+#define DUK_STRIDX_MINUS_INFINITY                                     104                            /* '-Infinity' */
-+#define DUK_STRIDX_PLUS_INFINITY                                      105                            /* '+Infinity' */
-+#define DUK_STRIDX_INFINITY                                           106                            /* 'Infinity' */
-+#define DUK_STRIDX_LC_OBJECT                                          107                            /* 'object' */
-+#define DUK_STRIDX_LC_STRING                                          108                            /* 'string' */
-+#define DUK_STRIDX_LC_NUMBER                                          109                            /* 'number' */
-+#define DUK_STRIDX_LC_BOOLEAN                                         110                            /* 'boolean' */
-+#define DUK_STRIDX_LC_UNDEFINED                                       111                            /* 'undefined' */
-+#define DUK_STRIDX_STRINGIFY                                          112                            /* 'stringify' */
-+#define DUK_STRIDX_TAN                                                113                            /* 'tan' */
-+#define DUK_STRIDX_SQRT                                               114                            /* 'sqrt' */
-+#define DUK_STRIDX_SIN                                                115                            /* 'sin' */
-+#define DUK_STRIDX_ROUND                                              116                            /* 'round' */
-+#define DUK_STRIDX_RANDOM                                             117                            /* 'random' */
-+#define DUK_STRIDX_POW                                                118                            /* 'pow' */
-+#define DUK_STRIDX_MIN                                                119                            /* 'min' */
-+#define DUK_STRIDX_MAX                                                120                            /* 'max' */
-+#define DUK_STRIDX_LOG                                                121                            /* 'log' */
-+#define DUK_STRIDX_FLOOR                                              122                            /* 'floor' */
-+#define DUK_STRIDX_EXP                                                123                            /* 'exp' */
-+#define DUK_STRIDX_COS                                                124                            /* 'cos' */
-+#define DUK_STRIDX_CEIL                                               125                            /* 'ceil' */
-+#define DUK_STRIDX_ATAN2                                              126                            /* 'atan2' */
-+#define DUK_STRIDX_ATAN                                               127                            /* 'atan' */
-+#define DUK_STRIDX_ASIN                                               128                            /* 'asin' */
-+#define DUK_STRIDX_ACOS                                               129                            /* 'acos' */
-+#define DUK_STRIDX_ABS                                                130                            /* 'abs' */
-+#define DUK_STRIDX_SQRT2                                              131                            /* 'SQRT2' */
-+#define DUK_STRIDX_SQRT1_2                                            132                            /* 'SQRT1_2' */
-+#define DUK_STRIDX_PI                                                 133                            /* 'PI' */
-+#define DUK_STRIDX_LOG10E                                             134                            /* 'LOG10E' */
-+#define DUK_STRIDX_LOG2E                                              135                            /* 'LOG2E' */
-+#define DUK_STRIDX_LN2                                                136                            /* 'LN2' */
-+#define DUK_STRIDX_LN10                                               137                            /* 'LN10' */
-+#define DUK_STRIDX_E                                                  138                            /* 'E' */
-+#define DUK_STRIDX_MESSAGE                                            139                            /* 'message' */
-+#define DUK_STRIDX_NAME                                               140                            /* 'name' */
-+#define DUK_STRIDX_INPUT                                              141                            /* 'input' */
-+#define DUK_STRIDX_INDEX                                              142                            /* 'index' */
-+#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP                               143                            /* '(?:)' */
-+#define DUK_STRIDX_LAST_INDEX                                         144                            /* 'lastIndex' */
-+#define DUK_STRIDX_MULTILINE                                          145                            /* 'multiline' */
-+#define DUK_STRIDX_IGNORE_CASE                                        146                            /* 'ignoreCase' */
-+#define DUK_STRIDX_SOURCE                                             147                            /* 'source' */
-+#define DUK_STRIDX_TEST                                               148                            /* 'test' */
-+#define DUK_STRIDX_EXEC                                               149                            /* 'exec' */
-+#define DUK_STRIDX_TO_GMT_STRING                                      150                            /* 'toGMTString' */
-+#define DUK_STRIDX_SET_YEAR                                           151                            /* 'setYear' */
-+#define DUK_STRIDX_GET_YEAR                                           152                            /* 'getYear' */
-+#define DUK_STRIDX_TO_JSON                                            153                            /* 'toJSON' */
-+#define DUK_STRIDX_TO_ISO_STRING                                      154                            /* 'toISOString' */
-+#define DUK_STRIDX_TO_UTC_STRING                                      155                            /* 'toUTCString' */
-+#define DUK_STRIDX_SET_UTC_FULL_YEAR                                  156                            /* 'setUTCFullYear' */
-+#define DUK_STRIDX_SET_FULL_YEAR                                      157                            /* 'setFullYear' */
-+#define DUK_STRIDX_SET_UTC_MONTH                                      158                            /* 'setUTCMonth' */
-+#define DUK_STRIDX_SET_MONTH                                          159                            /* 'setMonth' */
-+#define DUK_STRIDX_SET_UTC_DATE                                       160                            /* 'setUTCDate' */
-+#define DUK_STRIDX_SET_DATE                                           161                            /* 'setDate' */
-+#define DUK_STRIDX_SET_UTC_HOURS                                      162                            /* 'setUTCHours' */
-+#define DUK_STRIDX_SET_HOURS                                          163                            /* 'setHours' */
-+#define DUK_STRIDX_SET_UTC_MINUTES                                    164                            /* 'setUTCMinutes' */
-+#define DUK_STRIDX_SET_MINUTES                                        165                            /* 'setMinutes' */
-+#define DUK_STRIDX_SET_UTC_SECONDS                                    166                            /* 'setUTCSeconds' */
-+#define DUK_STRIDX_SET_SECONDS                                        167                            /* 'setSeconds' */
-+#define DUK_STRIDX_SET_UTC_MILLISECONDS                               168                            /* 'setUTCMilliseconds' */
-+#define DUK_STRIDX_SET_MILLISECONDS                                   169                            /* 'setMilliseconds' */
-+#define DUK_STRIDX_SET_TIME                                           170                            /* 'setTime' */
-+#define DUK_STRIDX_GET_TIMEZONE_OFFSET                                171                            /* 'getTimezoneOffset' */
-+#define DUK_STRIDX_GET_UTC_MILLISECONDS                               172                            /* 'getUTCMilliseconds' */
-+#define DUK_STRIDX_GET_MILLISECONDS                                   173                            /* 'getMilliseconds' */
-+#define DUK_STRIDX_GET_UTC_SECONDS                                    174                            /* 'getUTCSeconds' */
-+#define DUK_STRIDX_GET_SECONDS                                        175                            /* 'getSeconds' */
-+#define DUK_STRIDX_GET_UTC_MINUTES                                    176                            /* 'getUTCMinutes' */
-+#define DUK_STRIDX_GET_MINUTES                                        177                            /* 'getMinutes' */
-+#define DUK_STRIDX_GET_UTC_HOURS                                      178                            /* 'getUTCHours' */
-+#define DUK_STRIDX_GET_HOURS                                          179                            /* 'getHours' */
-+#define DUK_STRIDX_GET_UTC_DAY                                        180                            /* 'getUTCDay' */
-+#define DUK_STRIDX_GET_DAY                                            181                            /* 'getDay' */
-+#define DUK_STRIDX_GET_UTC_DATE                                       182                            /* 'getUTCDate' */
-+#define DUK_STRIDX_GET_DATE                                           183                            /* 'getDate' */
-+#define DUK_STRIDX_GET_UTC_MONTH                                      184                            /* 'getUTCMonth' */
-+#define DUK_STRIDX_GET_MONTH                                          185                            /* 'getMonth' */
-+#define DUK_STRIDX_GET_UTC_FULL_YEAR                                  186                            /* 'getUTCFullYear' */
-+#define DUK_STRIDX_GET_FULL_YEAR                                      187                            /* 'getFullYear' */
-+#define DUK_STRIDX_GET_TIME                                           188                            /* 'getTime' */
-+#define DUK_STRIDX_TO_LOCALE_TIME_STRING                              189                            /* 'toLocaleTimeString' */
-+#define DUK_STRIDX_TO_LOCALE_DATE_STRING                              190                            /* 'toLocaleDateString' */
-+#define DUK_STRIDX_TO_TIME_STRING                                     191                            /* 'toTimeString' */
-+#define DUK_STRIDX_TO_DATE_STRING                                     192                            /* 'toDateString' */
-+#define DUK_STRIDX_NOW                                                193                            /* 'now' */
-+#define DUK_STRIDX_UTC                                                194                            /* 'UTC' */
-+#define DUK_STRIDX_PARSE                                              195                            /* 'parse' */
-+#define DUK_STRIDX_TO_PRECISION                                       196                            /* 'toPrecision' */
-+#define DUK_STRIDX_TO_EXPONENTIAL                                     197                            /* 'toExponential' */
-+#define DUK_STRIDX_TO_FIXED                                           198                            /* 'toFixed' */
-+#define DUK_STRIDX_POSITIVE_INFINITY                                  199                            /* 'POSITIVE_INFINITY' */
-+#define DUK_STRIDX_NEGATIVE_INFINITY                                  200                            /* 'NEGATIVE_INFINITY' */
-+#define DUK_STRIDX_NAN                                                201                            /* 'NaN' */
-+#define DUK_STRIDX_MIN_VALUE                                          202                            /* 'MIN_VALUE' */
-+#define DUK_STRIDX_MAX_VALUE                                          203                            /* 'MAX_VALUE' */
-+#define DUK_STRIDX_SUBSTR                                             204                            /* 'substr' */
-+#define DUK_STRIDX_TRIM                                               205                            /* 'trim' */
-+#define DUK_STRIDX_TO_LOCALE_UPPER_CASE                               206                            /* 'toLocaleUpperCase' */
-+#define DUK_STRIDX_TO_UPPER_CASE                                      207                            /* 'toUpperCase' */
-+#define DUK_STRIDX_TO_LOCALE_LOWER_CASE                               208                            /* 'toLocaleLowerCase' */
-+#define DUK_STRIDX_TO_LOWER_CASE                                      209                            /* 'toLowerCase' */
-+#define DUK_STRIDX_SUBSTRING                                          210                            /* 'substring' */
-+#define DUK_STRIDX_SPLIT                                              211                            /* 'split' */
-+#define DUK_STRIDX_SEARCH                                             212                            /* 'search' */
-+#define DUK_STRIDX_REPLACE                                            213                            /* 'replace' */
-+#define DUK_STRIDX_MATCH                                              214                            /* 'match' */
-+#define DUK_STRIDX_LOCALE_COMPARE                                     215                            /* 'localeCompare' */
-+#define DUK_STRIDX_CHAR_CODE_AT                                       216                            /* 'charCodeAt' */
-+#define DUK_STRIDX_CHAR_AT                                            217                            /* 'charAt' */
-+#define DUK_STRIDX_FROM_CHAR_CODE                                     218                            /* 'fromCharCode' */
-+#define DUK_STRIDX_REDUCE_RIGHT                                       219                            /* 'reduceRight' */
-+#define DUK_STRIDX_REDUCE                                             220                            /* 'reduce' */
-+#define DUK_STRIDX_FILTER                                             221                            /* 'filter' */
-+#define DUK_STRIDX_MAP                                                222                            /* 'map' */
-+#define DUK_STRIDX_FOR_EACH                                           223                            /* 'forEach' */
-+#define DUK_STRIDX_SOME                                               224                            /* 'some' */
-+#define DUK_STRIDX_EVERY                                              225                            /* 'every' */
-+#define DUK_STRIDX_LAST_INDEX_OF                                      226                            /* 'lastIndexOf' */
-+#define DUK_STRIDX_INDEX_OF                                           227                            /* 'indexOf' */
-+#define DUK_STRIDX_UNSHIFT                                            228                            /* 'unshift' */
-+#define DUK_STRIDX_SPLICE                                             229                            /* 'splice' */
-+#define DUK_STRIDX_SORT                                               230                            /* 'sort' */
-+#define DUK_STRIDX_SLICE                                              231                            /* 'slice' */
-+#define DUK_STRIDX_SHIFT                                              232                            /* 'shift' */
-+#define DUK_STRIDX_REVERSE                                            233                            /* 'reverse' */
-+#define DUK_STRIDX_PUSH                                               234                            /* 'push' */
-+#define DUK_STRIDX_POP                                                235                            /* 'pop' */
-+#define DUK_STRIDX_JOIN                                               236                            /* 'join' */
-+#define DUK_STRIDX_CONCAT                                             237                            /* 'concat' */
-+#define DUK_STRIDX_IS_ARRAY                                           238                            /* 'isArray' */
-+#define DUK_STRIDX_LC_ARGUMENTS                                       239                            /* 'arguments' */
-+#define DUK_STRIDX_CALLER                                             240                            /* 'caller' */
-+#define DUK_STRIDX_BIND                                               241                            /* 'bind' */
-+#define DUK_STRIDX_CALL                                               242                            /* 'call' */
-+#define DUK_STRIDX_APPLY                                              243                            /* 'apply' */
-+#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE                             244                            /* 'propertyIsEnumerable' */
-+#define DUK_STRIDX_IS_PROTOTYPE_OF                                    245                            /* 'isPrototypeOf' */
-+#define DUK_STRIDX_HAS_OWN_PROPERTY                                   246                            /* 'hasOwnProperty' */
-+#define DUK_STRIDX_VALUE_OF                                           247                            /* 'valueOf' */
-+#define DUK_STRIDX_TO_LOCALE_STRING                                   248                            /* 'toLocaleString' */
-+#define DUK_STRIDX_TO_STRING                                          249                            /* 'toString' */
-+#define DUK_STRIDX_CONSTRUCTOR                                        250                            /* 'constructor' */
-+#define DUK_STRIDX_SET                                                251                            /* 'set' */
-+#define DUK_STRIDX_GET                                                252                            /* 'get' */
-+#define DUK_STRIDX_ENUMERABLE                                         253                            /* 'enumerable' */
-+#define DUK_STRIDX_CONFIGURABLE                                       254                            /* 'configurable' */
-+#define DUK_STRIDX_WRITABLE                                           255                            /* 'writable' */
-+#define DUK_STRIDX_VALUE                                              256                            /* 'value' */
-+#define DUK_STRIDX_KEYS                                               257                            /* 'keys' */
-+#define DUK_STRIDX_IS_EXTENSIBLE                                      258                            /* 'isExtensible' */
-+#define DUK_STRIDX_IS_FROZEN                                          259                            /* 'isFrozen' */
-+#define DUK_STRIDX_IS_SEALED                                          260                            /* 'isSealed' */
-+#define DUK_STRIDX_PREVENT_EXTENSIONS                                 261                            /* 'preventExtensions' */
-+#define DUK_STRIDX_FREEZE                                             262                            /* 'freeze' */
-+#define DUK_STRIDX_SEAL                                               263                            /* 'seal' */
-+#define DUK_STRIDX_DEFINE_PROPERTIES                                  264                            /* 'defineProperties' */
-+#define DUK_STRIDX_DEFINE_PROPERTY                                    265                            /* 'defineProperty' */
-+#define DUK_STRIDX_CREATE                                             266                            /* 'create' */
-+#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES                             267                            /* 'getOwnPropertyNames' */
-+#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR                        268                            /* 'getOwnPropertyDescriptor' */
-+#define DUK_STRIDX_GET_PROTOTYPE_OF                                   269                            /* 'getPrototypeOf' */
-+#define DUK_STRIDX_PROTOTYPE                                          270                            /* 'prototype' */
-+#define DUK_STRIDX_LENGTH                                             271                            /* 'length' */
-+#define DUK_STRIDX_ALERT                                              272                            /* 'alert' */
-+#define DUK_STRIDX_PRINT                                              273                            /* 'print' */
-+#define DUK_STRIDX_UNESCAPE                                           274                            /* 'unescape' */
-+#define DUK_STRIDX_ESCAPE                                             275                            /* 'escape' */
-+#define DUK_STRIDX_ENCODE_URI_COMPONENT                               276                            /* 'encodeURIComponent' */
-+#define DUK_STRIDX_ENCODE_URI                                         277                            /* 'encodeURI' */
-+#define DUK_STRIDX_DECODE_URI_COMPONENT                               278                            /* 'decodeURIComponent' */
-+#define DUK_STRIDX_DECODE_URI                                         279                            /* 'decodeURI' */
-+#define DUK_STRIDX_IS_FINITE                                          280                            /* 'isFinite' */
-+#define DUK_STRIDX_IS_NAN                                             281                            /* 'isNaN' */
-+#define DUK_STRIDX_PARSE_FLOAT                                        282                            /* 'parseFloat' */
-+#define DUK_STRIDX_PARSE_INT                                          283                            /* 'parseInt' */
-+#define DUK_STRIDX_EVAL                                               284                            /* 'eval' */
-+#define DUK_STRIDX_URI_ERROR                                          285                            /* 'URIError' */
-+#define DUK_STRIDX_TYPE_ERROR                                         286                            /* 'TypeError' */
-+#define DUK_STRIDX_SYNTAX_ERROR                                       287                            /* 'SyntaxError' */
-+#define DUK_STRIDX_REFERENCE_ERROR                                    288                            /* 'ReferenceError' */
-+#define DUK_STRIDX_RANGE_ERROR                                        289                            /* 'RangeError' */
-+#define DUK_STRIDX_EVAL_ERROR                                         290                            /* 'EvalError' */
-+#define DUK_STRIDX_BREAK                                              291                            /* 'break' */
-+#define DUK_STRIDX_CASE                                               292                            /* 'case' */
-+#define DUK_STRIDX_CATCH                                              293                            /* 'catch' */
-+#define DUK_STRIDX_CONTINUE                                           294                            /* 'continue' */
-+#define DUK_STRIDX_DEBUGGER                                           295                            /* 'debugger' */
-+#define DUK_STRIDX_DEFAULT                                            296                            /* 'default' */
-+#define DUK_STRIDX_DELETE                                             297                            /* 'delete' */
-+#define DUK_STRIDX_DO                                                 298                            /* 'do' */
-+#define DUK_STRIDX_ELSE                                               299                            /* 'else' */
-+#define DUK_STRIDX_FINALLY                                            300                            /* 'finally' */
-+#define DUK_STRIDX_FOR                                                301                            /* 'for' */
-+#define DUK_STRIDX_LC_FUNCTION                                        302                            /* 'function' */
-+#define DUK_STRIDX_IF                                                 303                            /* 'if' */
-+#define DUK_STRIDX_IN                                                 304                            /* 'in' */
-+#define DUK_STRIDX_INSTANCEOF                                         305                            /* 'instanceof' */
-+#define DUK_STRIDX_NEW                                                306                            /* 'new' */
-+#define DUK_STRIDX_RETURN                                             307                            /* 'return' */
-+#define DUK_STRIDX_SWITCH                                             308                            /* 'switch' */
-+#define DUK_STRIDX_THIS                                               309                            /* 'this' */
-+#define DUK_STRIDX_THROW                                              310                            /* 'throw' */
-+#define DUK_STRIDX_TRY                                                311                            /* 'try' */
-+#define DUK_STRIDX_TYPEOF                                             312                            /* 'typeof' */
-+#define DUK_STRIDX_VAR                                                313                            /* 'var' */
-+#define DUK_STRIDX_VOID                                               314                            /* 'void' */
-+#define DUK_STRIDX_WHILE                                              315                            /* 'while' */
-+#define DUK_STRIDX_WITH                                               316                            /* 'with' */
-+#define DUK_STRIDX_CLASS                                              317                            /* 'class' */
-+#define DUK_STRIDX_CONST                                              318                            /* 'const' */
-+#define DUK_STRIDX_ENUM                                               319                            /* 'enum' */
-+#define DUK_STRIDX_EXPORT                                             320                            /* 'export' */
-+#define DUK_STRIDX_EXTENDS                                            321                            /* 'extends' */
-+#define DUK_STRIDX_IMPORT                                             322                            /* 'import' */
-+#define DUK_STRIDX_SUPER                                              323                            /* 'super' */
-+#define DUK_STRIDX_LC_NULL                                            324                            /* 'null' */
-+#define DUK_STRIDX_TRUE                                               325                            /* 'true' */
-+#define DUK_STRIDX_FALSE                                              326                            /* 'false' */
-+#define DUK_STRIDX_IMPLEMENTS                                         327                            /* 'implements' */
-+#define DUK_STRIDX_INTERFACE                                          328                            /* 'interface' */
-+#define DUK_STRIDX_LET                                                329                            /* 'let' */
-+#define DUK_STRIDX_PACKAGE                                            330                            /* 'package' */
-+#define DUK_STRIDX_PRIVATE                                            331                            /* 'private' */
-+#define DUK_STRIDX_PROTECTED                                          332                            /* 'protected' */
-+#define DUK_STRIDX_PUBLIC                                             333                            /* 'public' */
-+#define DUK_STRIDX_STATIC                                             334                            /* 'static' */
-+#define DUK_STRIDX_YIELD                                              335                            /* 'yield' */
-+
-+#define DUK_HEAP_STRING_UC_LOGGER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER)
-+#define DUK_HTHREAD_STRING_UC_LOGGER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER)
-+#define DUK_HEAP_STRING_UC_THREAD(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD)
-+#define DUK_HTHREAD_STRING_UC_THREAD(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD)
-+#define DUK_HEAP_STRING_UC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER)
-+#define DUK_HTHREAD_STRING_UC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER)
-+#define DUK_HEAP_STRING_UC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER)
-+#define DUK_HTHREAD_STRING_UC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER)
-+#define DUK_HEAP_STRING_DEC_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV)
-+#define DUK_HTHREAD_STRING_DEC_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV)
-+#define DUK_HEAP_STRING_OBJ_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV)
-+#define DUK_HTHREAD_STRING_OBJ_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV)
-+#define DUK_HEAP_STRING_EMPTY_STRING(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING)
-+#define DUK_HTHREAD_STRING_EMPTY_STRING(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING)
-+#define DUK_HEAP_STRING_GLOBAL(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL)
-+#define DUK_HTHREAD_STRING_GLOBAL(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL)
-+#define DUK_HEAP_STRING_UC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS)
-+#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS)
-+#define DUK_HEAP_STRING_JSON(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON)
-+#define DUK_HTHREAD_STRING_JSON(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON)
-+#define DUK_HEAP_STRING_MATH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH)
-+#define DUK_HTHREAD_STRING_MATH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH)
-+#define DUK_HEAP_STRING_UC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR)
-+#define DUK_HTHREAD_STRING_UC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR)
-+#define DUK_HEAP_STRING_REG_EXP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP)
-+#define DUK_HTHREAD_STRING_REG_EXP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP)
-+#define DUK_HEAP_STRING_DATE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE)
-+#define DUK_HTHREAD_STRING_DATE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE)
-+#define DUK_HEAP_STRING_UC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER)
-+#define DUK_HTHREAD_STRING_UC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER)
-+#define DUK_HEAP_STRING_UC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN)
-+#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN)
-+#define DUK_HEAP_STRING_UC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING)
-+#define DUK_HTHREAD_STRING_UC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING)
-+#define DUK_HEAP_STRING_ARRAY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY)
-+#define DUK_HTHREAD_STRING_ARRAY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY)
-+#define DUK_HEAP_STRING_UC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION)
-+#define DUK_HTHREAD_STRING_UC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION)
-+#define DUK_HEAP_STRING_UC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT)
-+#define DUK_HTHREAD_STRING_UC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT)
-+#define DUK_HEAP_STRING_UC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL)
-+#define DUK_HTHREAD_STRING_UC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL)
-+#define DUK_HEAP_STRING_UC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED)
-+#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED)
-+#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2)
-+#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2)
-+#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1)
-+#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1)
-+#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF)
-+#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF)
-+#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF)
-+#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF)
-+#define DUK_HEAP_STRING_JSON_EXT_NAN(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN)
-+#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN)
-+#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED)
-+#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED)
-+#define DUK_HEAP_STRING_TO_LOG_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING)
-+#define DUK_HEAP_STRING_CLOG(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG)
-+#define DUK_HTHREAD_STRING_CLOG(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG)
-+#define DUK_HEAP_STRING_LC_L(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L)
-+#define DUK_HTHREAD_STRING_LC_L(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L)
-+#define DUK_HEAP_STRING_LC_N(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N)
-+#define DUK_HTHREAD_STRING_LC_N(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N)
-+#define DUK_HEAP_STRING_LC_FATAL(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL)
-+#define DUK_HTHREAD_STRING_LC_FATAL(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL)
-+#define DUK_HEAP_STRING_LC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR)
-+#define DUK_HTHREAD_STRING_LC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR)
-+#define DUK_HEAP_STRING_LC_WARN(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN)
-+#define DUK_HTHREAD_STRING_LC_WARN(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN)
-+#define DUK_HEAP_STRING_LC_DEBUG(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG)
-+#define DUK_HTHREAD_STRING_LC_DEBUG(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG)
-+#define DUK_HEAP_STRING_LC_TRACE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE)
-+#define DUK_HTHREAD_STRING_LC_TRACE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE)
-+#define DUK_HEAP_STRING_RAW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW)
-+#define DUK_HTHREAD_STRING_RAW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW)
-+#define DUK_HEAP_STRING_FMT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT)
-+#define DUK_HTHREAD_STRING_FMT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT)
-+#define DUK_HEAP_STRING_CURRENT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT)
-+#define DUK_HTHREAD_STRING_CURRENT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT)
-+#define DUK_HEAP_STRING_RESUME(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME)
-+#define DUK_HTHREAD_STRING_RESUME(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME)
-+#define DUK_HEAP_STRING_COMPACT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT)
-+#define DUK_HTHREAD_STRING_COMPACT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT)
-+#define DUK_HEAP_STRING_JC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC)
-+#define DUK_HTHREAD_STRING_JC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC)
-+#define DUK_HEAP_STRING_JX(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX)
-+#define DUK_HTHREAD_STRING_JX(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX)
-+#define DUK_HEAP_STRING_BASE64(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64)
-+#define DUK_HTHREAD_STRING_BASE64(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64)
-+#define DUK_HEAP_STRING_HEX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX)
-+#define DUK_HTHREAD_STRING_HEX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX)
-+#define DUK_HEAP_STRING_DEC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC)
-+#define DUK_HTHREAD_STRING_DEC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC)
-+#define DUK_HEAP_STRING_ENC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC)
-+#define DUK_HTHREAD_STRING_ENC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC)
-+#define DUK_HEAP_STRING_FIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN)
-+#define DUK_HTHREAD_STRING_FIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN)
-+#define DUK_HEAP_STRING_GC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC)
-+#define DUK_HTHREAD_STRING_GC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC)
-+#define DUK_HEAP_STRING_ACT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT)
-+#define DUK_HTHREAD_STRING_ACT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT)
-+#define DUK_HEAP_STRING_LC_INFO(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO)
-+#define DUK_HTHREAD_STRING_LC_INFO(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO)
-+#define DUK_HEAP_STRING_VERSION(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION)
-+#define DUK_HTHREAD_STRING_VERSION(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION)
-+#define DUK_HEAP_STRING_ENV(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV)
-+#define DUK_HTHREAD_STRING_ENV(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV)
-+#define DUK_HEAP_STRING_MOD_LOADED(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED)
-+#define DUK_HTHREAD_STRING_MOD_LOADED(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED)
-+#define DUK_HEAP_STRING_MOD_SEARCH(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH)
-+#define DUK_HTHREAD_STRING_MOD_SEARCH(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH)
-+#define DUK_HEAP_STRING_ERR_THROW(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW)
-+#define DUK_HTHREAD_STRING_ERR_THROW(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW)
-+#define DUK_HEAP_STRING_ERR_CREATE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE)
-+#define DUK_HTHREAD_STRING_ERR_CREATE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE)
-+#define DUK_HEAP_STRING_COMPILE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE)
-+#define DUK_HTHREAD_STRING_COMPILE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE)
-+#define DUK_HEAP_STRING_INT_REGBASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE)
-+#define DUK_HTHREAD_STRING_INT_REGBASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE)
-+#define DUK_HEAP_STRING_INT_THREAD(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD)
-+#define DUK_HTHREAD_STRING_INT_THREAD(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD)
-+#define DUK_HEAP_STRING_INT_HANDLER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER)
-+#define DUK_HTHREAD_STRING_INT_HANDLER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER)
-+#define DUK_HEAP_STRING_INT_FINALIZER(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER)
-+#define DUK_HTHREAD_STRING_INT_FINALIZER(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER)
-+#define DUK_HEAP_STRING_INT_CALLEE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE)
-+#define DUK_HTHREAD_STRING_INT_CALLEE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE)
-+#define DUK_HEAP_STRING_INT_MAP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP)
-+#define DUK_HTHREAD_STRING_INT_MAP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP)
-+#define DUK_HEAP_STRING_INT_ARGS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS)
-+#define DUK_HTHREAD_STRING_INT_ARGS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS)
-+#define DUK_HEAP_STRING_INT_THIS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS)
-+#define DUK_HTHREAD_STRING_INT_THIS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS)
-+#define DUK_HEAP_STRING_INT_PC2LINE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE)
-+#define DUK_HTHREAD_STRING_INT_PC2LINE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE)
-+#define DUK_HEAP_STRING_INT_SOURCE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE)
-+#define DUK_HTHREAD_STRING_INT_SOURCE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE)
-+#define DUK_HEAP_STRING_INT_VARENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV)
-+#define DUK_HTHREAD_STRING_INT_VARENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV)
-+#define DUK_HEAP_STRING_INT_LEXENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV)
-+#define DUK_HTHREAD_STRING_INT_LEXENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV)
-+#define DUK_HEAP_STRING_INT_VARMAP(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP)
-+#define DUK_HTHREAD_STRING_INT_VARMAP(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP)
-+#define DUK_HEAP_STRING_INT_FORMALS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS)
-+#define DUK_HTHREAD_STRING_INT_FORMALS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS)
-+#define DUK_HEAP_STRING_INT_BYTECODE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE)
-+#define DUK_HTHREAD_STRING_INT_BYTECODE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE)
-+#define DUK_HEAP_STRING_INT_NEXT(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT)
-+#define DUK_HTHREAD_STRING_INT_NEXT(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT)
-+#define DUK_HEAP_STRING_INT_TARGET(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET)
-+#define DUK_HTHREAD_STRING_INT_TARGET(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET)
-+#define DUK_HEAP_STRING_INT_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE)
-+#define DUK_HTHREAD_STRING_INT_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE)
-+#define DUK_HEAP_STRING_LC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER)
-+#define DUK_HTHREAD_STRING_LC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER)
-+#define DUK_HEAP_STRING_LC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER)
-+#define DUK_HTHREAD_STRING_LC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER)
-+#define DUK_HEAP_STRING_INT_TRACEDATA(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA)
-+#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA)
-+#define DUK_HEAP_STRING_LINE_NUMBER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER)
-+#define DUK_HTHREAD_STRING_LINE_NUMBER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER)
-+#define DUK_HEAP_STRING_FILE_NAME(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME)
-+#define DUK_HTHREAD_STRING_FILE_NAME(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME)
-+#define DUK_HEAP_STRING_PC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC)
-+#define DUK_HTHREAD_STRING_PC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC)
-+#define DUK_HEAP_STRING_STACK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK)
-+#define DUK_HTHREAD_STRING_STACK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK)
-+#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR)
-+#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR)
-+#define DUK_HEAP_STRING_DUKTAPE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE)
-+#define DUK_HTHREAD_STRING_DUKTAPE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE)
-+#define DUK_HEAP_STRING_ID(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID)
-+#define DUK_HTHREAD_STRING_ID(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID)
-+#define DUK_HEAP_STRING_REQUIRE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE)
-+#define DUK_HTHREAD_STRING_REQUIRE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE)
-+#define DUK_HEAP_STRING___PROTO__(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__)
-+#define DUK_HTHREAD_STRING___PROTO__(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__)
-+#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_OWN_KEYS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS)
-+#define DUK_HTHREAD_STRING_OWN_KEYS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS)
-+#define DUK_HEAP_STRING_ENUMERATE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE)
-+#define DUK_HTHREAD_STRING_ENUMERATE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE)
-+#define DUK_HEAP_STRING_DELETE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY)
-+#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY)
-+#define DUK_HEAP_STRING_HAS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS)
-+#define DUK_HTHREAD_STRING_HAS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS)
-+#define DUK_HEAP_STRING_PROXY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY)
-+#define DUK_HTHREAD_STRING_PROXY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY)
-+#define DUK_HEAP_STRING_CALLEE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE)
-+#define DUK_HTHREAD_STRING_CALLEE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE)
-+#define DUK_HEAP_STRING_INVALID_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE)
-+#define DUK_HTHREAD_STRING_INVALID_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE)
-+#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS)
-+#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS)
-+#define DUK_HEAP_STRING_NEWLINE_TAB(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB)
-+#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB)
-+#define DUK_HEAP_STRING_SPACE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE)
-+#define DUK_HTHREAD_STRING_SPACE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE)
-+#define DUK_HEAP_STRING_COMMA(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA)
-+#define DUK_HTHREAD_STRING_COMMA(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA)
-+#define DUK_HEAP_STRING_MINUS_ZERO(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO)
-+#define DUK_HTHREAD_STRING_MINUS_ZERO(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO)
-+#define DUK_HEAP_STRING_PLUS_ZERO(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO)
-+#define DUK_HTHREAD_STRING_PLUS_ZERO(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO)
-+#define DUK_HEAP_STRING_ZERO(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO)
-+#define DUK_HTHREAD_STRING_ZERO(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO)
-+#define DUK_HEAP_STRING_MINUS_INFINITY(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY)
-+#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY)
-+#define DUK_HEAP_STRING_PLUS_INFINITY(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY)
-+#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY)
-+#define DUK_HEAP_STRING_INFINITY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY)
-+#define DUK_HTHREAD_STRING_INFINITY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY)
-+#define DUK_HEAP_STRING_LC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT)
-+#define DUK_HTHREAD_STRING_LC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT)
-+#define DUK_HEAP_STRING_LC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING)
-+#define DUK_HTHREAD_STRING_LC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING)
-+#define DUK_HEAP_STRING_LC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER)
-+#define DUK_HTHREAD_STRING_LC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER)
-+#define DUK_HEAP_STRING_LC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN)
-+#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN)
-+#define DUK_HEAP_STRING_LC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED)
-+#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED)
-+#define DUK_HEAP_STRING_STRINGIFY(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY)
-+#define DUK_HTHREAD_STRING_STRINGIFY(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY)
-+#define DUK_HEAP_STRING_TAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN)
-+#define DUK_HTHREAD_STRING_TAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN)
-+#define DUK_HEAP_STRING_SQRT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT)
-+#define DUK_HTHREAD_STRING_SQRT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT)
-+#define DUK_HEAP_STRING_SIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN)
-+#define DUK_HTHREAD_STRING_SIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN)
-+#define DUK_HEAP_STRING_ROUND(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND)
-+#define DUK_HTHREAD_STRING_ROUND(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND)
-+#define DUK_HEAP_STRING_RANDOM(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM)
-+#define DUK_HTHREAD_STRING_RANDOM(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM)
-+#define DUK_HEAP_STRING_POW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW)
-+#define DUK_HTHREAD_STRING_POW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW)
-+#define DUK_HEAP_STRING_MIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN)
-+#define DUK_HTHREAD_STRING_MIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN)
-+#define DUK_HEAP_STRING_MAX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX)
-+#define DUK_HTHREAD_STRING_MAX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX)
-+#define DUK_HEAP_STRING_LOG(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG)
-+#define DUK_HTHREAD_STRING_LOG(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG)
-+#define DUK_HEAP_STRING_FLOOR(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR)
-+#define DUK_HTHREAD_STRING_FLOOR(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR)
-+#define DUK_HEAP_STRING_EXP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP)
-+#define DUK_HTHREAD_STRING_EXP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP)
-+#define DUK_HEAP_STRING_COS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS)
-+#define DUK_HTHREAD_STRING_COS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS)
-+#define DUK_HEAP_STRING_CEIL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL)
-+#define DUK_HTHREAD_STRING_CEIL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL)
-+#define DUK_HEAP_STRING_ATAN2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2)
-+#define DUK_HTHREAD_STRING_ATAN2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2)
-+#define DUK_HEAP_STRING_ATAN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN)
-+#define DUK_HTHREAD_STRING_ATAN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN)
-+#define DUK_HEAP_STRING_ASIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN)
-+#define DUK_HTHREAD_STRING_ASIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN)
-+#define DUK_HEAP_STRING_ACOS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS)
-+#define DUK_HTHREAD_STRING_ACOS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS)
-+#define DUK_HEAP_STRING_ABS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS)
-+#define DUK_HTHREAD_STRING_ABS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS)
-+#define DUK_HEAP_STRING_SQRT2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2)
-+#define DUK_HTHREAD_STRING_SQRT2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2)
-+#define DUK_HEAP_STRING_SQRT1_2(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2)
-+#define DUK_HTHREAD_STRING_SQRT1_2(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2)
-+#define DUK_HEAP_STRING_PI(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI)
-+#define DUK_HTHREAD_STRING_PI(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI)
-+#define DUK_HEAP_STRING_LOG10E(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E)
-+#define DUK_HTHREAD_STRING_LOG10E(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E)
-+#define DUK_HEAP_STRING_LOG2E(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E)
-+#define DUK_HTHREAD_STRING_LOG2E(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E)
-+#define DUK_HEAP_STRING_LN2(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2)
-+#define DUK_HTHREAD_STRING_LN2(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2)
-+#define DUK_HEAP_STRING_LN10(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10)
-+#define DUK_HTHREAD_STRING_LN10(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10)
-+#define DUK_HEAP_STRING_E(heap)                                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E)
-+#define DUK_HTHREAD_STRING_E(thr)                                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E)
-+#define DUK_HEAP_STRING_MESSAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE)
-+#define DUK_HTHREAD_STRING_MESSAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE)
-+#define DUK_HEAP_STRING_NAME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME)
-+#define DUK_HTHREAD_STRING_NAME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME)
-+#define DUK_HEAP_STRING_INPUT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT)
-+#define DUK_HTHREAD_STRING_INPUT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT)
-+#define DUK_HEAP_STRING_INDEX(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX)
-+#define DUK_HTHREAD_STRING_INDEX(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX)
-+#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
-+#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
-+#define DUK_HEAP_STRING_LAST_INDEX(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX)
-+#define DUK_HTHREAD_STRING_LAST_INDEX(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX)
-+#define DUK_HEAP_STRING_MULTILINE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE)
-+#define DUK_HTHREAD_STRING_MULTILINE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE)
-+#define DUK_HEAP_STRING_IGNORE_CASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE)
-+#define DUK_HTHREAD_STRING_IGNORE_CASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE)
-+#define DUK_HEAP_STRING_SOURCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE)
-+#define DUK_HTHREAD_STRING_SOURCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE)
-+#define DUK_HEAP_STRING_TEST(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST)
-+#define DUK_HTHREAD_STRING_TEST(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST)
-+#define DUK_HEAP_STRING_EXEC(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC)
-+#define DUK_HTHREAD_STRING_EXEC(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC)
-+#define DUK_HEAP_STRING_TO_GMT_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING)
-+#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING)
-+#define DUK_HEAP_STRING_SET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR)
-+#define DUK_HTHREAD_STRING_SET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR)
-+#define DUK_HEAP_STRING_GET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR)
-+#define DUK_HTHREAD_STRING_GET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR)
-+#define DUK_HEAP_STRING_TO_JSON(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON)
-+#define DUK_HTHREAD_STRING_TO_JSON(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON)
-+#define DUK_HEAP_STRING_TO_ISO_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING)
-+#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING)
-+#define DUK_HEAP_STRING_TO_UTC_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING)
-+#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING)
-+#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR)
-+#define DUK_HEAP_STRING_SET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR)
-+#define DUK_HEAP_STRING_SET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH)
-+#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH)
-+#define DUK_HEAP_STRING_SET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH)
-+#define DUK_HTHREAD_STRING_SET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH)
-+#define DUK_HEAP_STRING_SET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE)
-+#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE)
-+#define DUK_HEAP_STRING_SET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE)
-+#define DUK_HTHREAD_STRING_SET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE)
-+#define DUK_HEAP_STRING_SET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS)
-+#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS)
-+#define DUK_HEAP_STRING_SET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS)
-+#define DUK_HTHREAD_STRING_SET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS)
-+#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES)
-+#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES)
-+#define DUK_HEAP_STRING_SET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES)
-+#define DUK_HTHREAD_STRING_SET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES)
-+#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS)
-+#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS)
-+#define DUK_HEAP_STRING_SET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS)
-+#define DUK_HTHREAD_STRING_SET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS)
-+#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS)
-+#define DUK_HEAP_STRING_SET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS)
-+#define DUK_HEAP_STRING_SET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME)
-+#define DUK_HTHREAD_STRING_SET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME)
-+#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap)                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET)
-+#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr)                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET)
-+#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS)
-+#define DUK_HEAP_STRING_GET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS)
-+#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS)
-+#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS)
-+#define DUK_HEAP_STRING_GET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS)
-+#define DUK_HTHREAD_STRING_GET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS)
-+#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES)
-+#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES)
-+#define DUK_HEAP_STRING_GET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES)
-+#define DUK_HTHREAD_STRING_GET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES)
-+#define DUK_HEAP_STRING_GET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS)
-+#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS)
-+#define DUK_HEAP_STRING_GET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS)
-+#define DUK_HTHREAD_STRING_GET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS)
-+#define DUK_HEAP_STRING_GET_UTC_DAY(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY)
-+#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY)
-+#define DUK_HEAP_STRING_GET_DAY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY)
-+#define DUK_HTHREAD_STRING_GET_DAY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY)
-+#define DUK_HEAP_STRING_GET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE)
-+#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE)
-+#define DUK_HEAP_STRING_GET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE)
-+#define DUK_HTHREAD_STRING_GET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE)
-+#define DUK_HEAP_STRING_GET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH)
-+#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH)
-+#define DUK_HEAP_STRING_GET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH)
-+#define DUK_HTHREAD_STRING_GET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH)
-+#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR)
-+#define DUK_HEAP_STRING_GET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR)
-+#define DUK_HEAP_STRING_GET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME)
-+#define DUK_HTHREAD_STRING_GET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME)
-+#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING)
-+#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING)
-+#define DUK_HEAP_STRING_TO_TIME_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING)
-+#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING)
-+#define DUK_HEAP_STRING_TO_DATE_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING)
-+#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING)
-+#define DUK_HEAP_STRING_NOW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW)
-+#define DUK_HTHREAD_STRING_NOW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW)
-+#define DUK_HEAP_STRING_UTC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC)
-+#define DUK_HTHREAD_STRING_UTC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC)
-+#define DUK_HEAP_STRING_PARSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE)
-+#define DUK_HTHREAD_STRING_PARSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE)
-+#define DUK_HEAP_STRING_TO_PRECISION(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION)
-+#define DUK_HTHREAD_STRING_TO_PRECISION(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION)
-+#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL)
-+#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL)
-+#define DUK_HEAP_STRING_TO_FIXED(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED)
-+#define DUK_HTHREAD_STRING_TO_FIXED(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED)
-+#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY)
-+#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY)
-+#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY)
-+#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY)
-+#define DUK_HEAP_STRING_NAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN)
-+#define DUK_HTHREAD_STRING_NAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN)
-+#define DUK_HEAP_STRING_MIN_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE)
-+#define DUK_HTHREAD_STRING_MIN_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE)
-+#define DUK_HEAP_STRING_MAX_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE)
-+#define DUK_HTHREAD_STRING_MAX_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE)
-+#define DUK_HEAP_STRING_SUBSTR(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR)
-+#define DUK_HTHREAD_STRING_SUBSTR(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR)
-+#define DUK_HEAP_STRING_TRIM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM)
-+#define DUK_HTHREAD_STRING_TRIM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM)
-+#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
-+#define DUK_HEAP_STRING_TO_UPPER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE)
-+#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE)
-+#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
-+#define DUK_HEAP_STRING_TO_LOWER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE)
-+#define DUK_HEAP_STRING_SUBSTRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING)
-+#define DUK_HTHREAD_STRING_SUBSTRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING)
-+#define DUK_HEAP_STRING_SPLIT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT)
-+#define DUK_HTHREAD_STRING_SPLIT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT)
-+#define DUK_HEAP_STRING_SEARCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH)
-+#define DUK_HTHREAD_STRING_SEARCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH)
-+#define DUK_HEAP_STRING_REPLACE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE)
-+#define DUK_HTHREAD_STRING_REPLACE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE)
-+#define DUK_HEAP_STRING_MATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH)
-+#define DUK_HTHREAD_STRING_MATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH)
-+#define DUK_HEAP_STRING_LOCALE_COMPARE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE)
-+#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE)
-+#define DUK_HEAP_STRING_CHAR_CODE_AT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT)
-+#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT)
-+#define DUK_HEAP_STRING_CHAR_AT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT)
-+#define DUK_HTHREAD_STRING_CHAR_AT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT)
-+#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE)
-+#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE)
-+#define DUK_HEAP_STRING_REDUCE_RIGHT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT)
-+#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT)
-+#define DUK_HEAP_STRING_REDUCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE)
-+#define DUK_HTHREAD_STRING_REDUCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE)
-+#define DUK_HEAP_STRING_FILTER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER)
-+#define DUK_HTHREAD_STRING_FILTER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER)
-+#define DUK_HEAP_STRING_MAP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP)
-+#define DUK_HTHREAD_STRING_MAP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP)
-+#define DUK_HEAP_STRING_FOR_EACH(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH)
-+#define DUK_HTHREAD_STRING_FOR_EACH(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH)
-+#define DUK_HEAP_STRING_SOME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME)
-+#define DUK_HTHREAD_STRING_SOME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME)
-+#define DUK_HEAP_STRING_EVERY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY)
-+#define DUK_HTHREAD_STRING_EVERY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY)
-+#define DUK_HEAP_STRING_LAST_INDEX_OF(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF)
-+#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF)
-+#define DUK_HEAP_STRING_INDEX_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF)
-+#define DUK_HTHREAD_STRING_INDEX_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF)
-+#define DUK_HEAP_STRING_UNSHIFT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT)
-+#define DUK_HTHREAD_STRING_UNSHIFT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT)
-+#define DUK_HEAP_STRING_SPLICE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE)
-+#define DUK_HTHREAD_STRING_SPLICE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE)
-+#define DUK_HEAP_STRING_SORT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT)
-+#define DUK_HTHREAD_STRING_SORT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT)
-+#define DUK_HEAP_STRING_SLICE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE)
-+#define DUK_HTHREAD_STRING_SLICE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE)
-+#define DUK_HEAP_STRING_SHIFT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT)
-+#define DUK_HTHREAD_STRING_SHIFT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT)
-+#define DUK_HEAP_STRING_REVERSE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE)
-+#define DUK_HTHREAD_STRING_REVERSE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE)
-+#define DUK_HEAP_STRING_PUSH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH)
-+#define DUK_HTHREAD_STRING_PUSH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH)
-+#define DUK_HEAP_STRING_POP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP)
-+#define DUK_HTHREAD_STRING_POP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP)
-+#define DUK_HEAP_STRING_JOIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN)
-+#define DUK_HTHREAD_STRING_JOIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN)
-+#define DUK_HEAP_STRING_CONCAT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT)
-+#define DUK_HTHREAD_STRING_CONCAT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT)
-+#define DUK_HEAP_STRING_IS_ARRAY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY)
-+#define DUK_HTHREAD_STRING_IS_ARRAY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY)
-+#define DUK_HEAP_STRING_LC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS)
-+#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)
-+#define DUK_HEAP_STRING_CALLER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER)
-+#define DUK_HTHREAD_STRING_CALLER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER)
-+#define DUK_HEAP_STRING_BIND(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND)
-+#define DUK_HTHREAD_STRING_BIND(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND)
-+#define DUK_HEAP_STRING_CALL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL)
-+#define DUK_HTHREAD_STRING_CALL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL)
-+#define DUK_HEAP_STRING_APPLY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY)
-+#define DUK_HTHREAD_STRING_APPLY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY)
-+#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
-+#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
-+#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY)
-+#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY)
-+#define DUK_HEAP_STRING_VALUE_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF)
-+#define DUK_HTHREAD_STRING_VALUE_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF)
-+#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING)
-+#define DUK_HEAP_STRING_TO_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING)
-+#define DUK_HTHREAD_STRING_TO_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING)
-+#define DUK_HEAP_STRING_CONSTRUCTOR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR)
-+#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR)
-+#define DUK_HEAP_STRING_SET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET)
-+#define DUK_HTHREAD_STRING_SET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET)
-+#define DUK_HEAP_STRING_GET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET)
-+#define DUK_HTHREAD_STRING_GET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET)
-+#define DUK_HEAP_STRING_ENUMERABLE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE)
-+#define DUK_HTHREAD_STRING_ENUMERABLE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE)
-+#define DUK_HEAP_STRING_CONFIGURABLE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE)
-+#define DUK_HTHREAD_STRING_CONFIGURABLE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE)
-+#define DUK_HEAP_STRING_WRITABLE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE)
-+#define DUK_HTHREAD_STRING_WRITABLE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE)
-+#define DUK_HEAP_STRING_VALUE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE)
-+#define DUK_HTHREAD_STRING_VALUE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE)
-+#define DUK_HEAP_STRING_KEYS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS)
-+#define DUK_HTHREAD_STRING_KEYS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS)
-+#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE)
-+#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE)
-+#define DUK_HEAP_STRING_IS_FROZEN(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN)
-+#define DUK_HTHREAD_STRING_IS_FROZEN(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN)
-+#define DUK_HEAP_STRING_IS_SEALED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED)
-+#define DUK_HTHREAD_STRING_IS_SEALED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED)
-+#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS)
-+#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS)
-+#define DUK_HEAP_STRING_FREEZE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE)
-+#define DUK_HTHREAD_STRING_FREEZE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE)
-+#define DUK_HEAP_STRING_SEAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL)
-+#define DUK_HTHREAD_STRING_SEAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL)
-+#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES)
-+#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES)
-+#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY)
-+#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY)
-+#define DUK_HEAP_STRING_CREATE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE)
-+#define DUK_HTHREAD_STRING_CREATE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE)
-+#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
-+#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
-+#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap)             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
-+#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr)           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
-+#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_PROTOTYPE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE)
-+#define DUK_HTHREAD_STRING_PROTOTYPE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE)
-+#define DUK_HEAP_STRING_LENGTH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH)
-+#define DUK_HTHREAD_STRING_LENGTH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)
-+#define DUK_HEAP_STRING_ALERT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT)
-+#define DUK_HTHREAD_STRING_ALERT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT)
-+#define DUK_HEAP_STRING_PRINT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT)
-+#define DUK_HTHREAD_STRING_PRINT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT)
-+#define DUK_HEAP_STRING_UNESCAPE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE)
-+#define DUK_HTHREAD_STRING_UNESCAPE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE)
-+#define DUK_HEAP_STRING_ESCAPE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE)
-+#define DUK_HTHREAD_STRING_ESCAPE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE)
-+#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT)
-+#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT)
-+#define DUK_HEAP_STRING_ENCODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI)
-+#define DUK_HTHREAD_STRING_ENCODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI)
-+#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT)
-+#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT)
-+#define DUK_HEAP_STRING_DECODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI)
-+#define DUK_HTHREAD_STRING_DECODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI)
-+#define DUK_HEAP_STRING_IS_FINITE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE)
-+#define DUK_HTHREAD_STRING_IS_FINITE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE)
-+#define DUK_HEAP_STRING_IS_NAN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN)
-+#define DUK_HTHREAD_STRING_IS_NAN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN)
-+#define DUK_HEAP_STRING_PARSE_FLOAT(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT)
-+#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT)
-+#define DUK_HEAP_STRING_PARSE_INT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT)
-+#define DUK_HTHREAD_STRING_PARSE_INT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT)
-+#define DUK_HEAP_STRING_EVAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL)
-+#define DUK_HTHREAD_STRING_EVAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL)
-+#define DUK_HEAP_STRING_URI_ERROR(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR)
-+#define DUK_HTHREAD_STRING_URI_ERROR(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR)
-+#define DUK_HEAP_STRING_TYPE_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR)
-+#define DUK_HTHREAD_STRING_TYPE_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR)
-+#define DUK_HEAP_STRING_SYNTAX_ERROR(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR)
-+#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR)
-+#define DUK_HEAP_STRING_REFERENCE_ERROR(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR)
-+#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR)
-+#define DUK_HEAP_STRING_RANGE_ERROR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR)
-+#define DUK_HTHREAD_STRING_RANGE_ERROR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR)
-+#define DUK_HEAP_STRING_EVAL_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR)
-+#define DUK_HTHREAD_STRING_EVAL_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR)
-+#define DUK_HEAP_STRING_BREAK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK)
-+#define DUK_HTHREAD_STRING_BREAK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK)
-+#define DUK_HEAP_STRING_CASE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE)
-+#define DUK_HTHREAD_STRING_CASE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE)
-+#define DUK_HEAP_STRING_CATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH)
-+#define DUK_HTHREAD_STRING_CATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH)
-+#define DUK_HEAP_STRING_CONTINUE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE)
-+#define DUK_HTHREAD_STRING_CONTINUE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE)
-+#define DUK_HEAP_STRING_DEBUGGER(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER)
-+#define DUK_HTHREAD_STRING_DEBUGGER(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER)
-+#define DUK_HEAP_STRING_DEFAULT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT)
-+#define DUK_HTHREAD_STRING_DEFAULT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT)
-+#define DUK_HEAP_STRING_DELETE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE)
-+#define DUK_HTHREAD_STRING_DELETE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE)
-+#define DUK_HEAP_STRING_DO(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO)
-+#define DUK_HTHREAD_STRING_DO(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO)
-+#define DUK_HEAP_STRING_ELSE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE)
-+#define DUK_HTHREAD_STRING_ELSE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE)
-+#define DUK_HEAP_STRING_FINALLY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY)
-+#define DUK_HTHREAD_STRING_FINALLY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY)
-+#define DUK_HEAP_STRING_FOR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR)
-+#define DUK_HTHREAD_STRING_FOR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR)
-+#define DUK_HEAP_STRING_LC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION)
-+#define DUK_HTHREAD_STRING_LC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION)
-+#define DUK_HEAP_STRING_IF(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF)
-+#define DUK_HTHREAD_STRING_IF(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF)
-+#define DUK_HEAP_STRING_IN(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN)
-+#define DUK_HTHREAD_STRING_IN(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN)
-+#define DUK_HEAP_STRING_INSTANCEOF(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF)
-+#define DUK_HTHREAD_STRING_INSTANCEOF(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF)
-+#define DUK_HEAP_STRING_NEW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW)
-+#define DUK_HTHREAD_STRING_NEW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW)
-+#define DUK_HEAP_STRING_RETURN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN)
-+#define DUK_HTHREAD_STRING_RETURN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN)
-+#define DUK_HEAP_STRING_SWITCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH)
-+#define DUK_HTHREAD_STRING_SWITCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH)
-+#define DUK_HEAP_STRING_THIS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS)
-+#define DUK_HTHREAD_STRING_THIS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS)
-+#define DUK_HEAP_STRING_THROW(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW)
-+#define DUK_HTHREAD_STRING_THROW(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW)
-+#define DUK_HEAP_STRING_TRY(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY)
-+#define DUK_HTHREAD_STRING_TRY(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY)
-+#define DUK_HEAP_STRING_TYPEOF(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF)
-+#define DUK_HTHREAD_STRING_TYPEOF(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF)
-+#define DUK_HEAP_STRING_VAR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR)
-+#define DUK_HTHREAD_STRING_VAR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR)
-+#define DUK_HEAP_STRING_VOID(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID)
-+#define DUK_HTHREAD_STRING_VOID(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID)
-+#define DUK_HEAP_STRING_WHILE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE)
-+#define DUK_HTHREAD_STRING_WHILE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE)
-+#define DUK_HEAP_STRING_WITH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH)
-+#define DUK_HTHREAD_STRING_WITH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH)
-+#define DUK_HEAP_STRING_CLASS(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS)
-+#define DUK_HTHREAD_STRING_CLASS(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS)
-+#define DUK_HEAP_STRING_CONST(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST)
-+#define DUK_HTHREAD_STRING_CONST(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST)
-+#define DUK_HEAP_STRING_ENUM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM)
-+#define DUK_HTHREAD_STRING_ENUM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM)
-+#define DUK_HEAP_STRING_EXPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT)
-+#define DUK_HTHREAD_STRING_EXPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT)
-+#define DUK_HEAP_STRING_EXTENDS(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS)
-+#define DUK_HTHREAD_STRING_EXTENDS(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS)
-+#define DUK_HEAP_STRING_IMPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT)
-+#define DUK_HTHREAD_STRING_IMPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT)
-+#define DUK_HEAP_STRING_SUPER(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER)
-+#define DUK_HTHREAD_STRING_SUPER(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER)
-+#define DUK_HEAP_STRING_LC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL)
-+#define DUK_HTHREAD_STRING_LC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL)
-+#define DUK_HEAP_STRING_TRUE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE)
-+#define DUK_HTHREAD_STRING_TRUE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE)
-+#define DUK_HEAP_STRING_FALSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE)
-+#define DUK_HTHREAD_STRING_FALSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE)
-+#define DUK_HEAP_STRING_IMPLEMENTS(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS)
-+#define DUK_HTHREAD_STRING_IMPLEMENTS(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS)
-+#define DUK_HEAP_STRING_INTERFACE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE)
-+#define DUK_HTHREAD_STRING_INTERFACE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE)
-+#define DUK_HEAP_STRING_LET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET)
-+#define DUK_HTHREAD_STRING_LET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET)
-+#define DUK_HEAP_STRING_PACKAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE)
-+#define DUK_HTHREAD_STRING_PACKAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE)
-+#define DUK_HEAP_STRING_PRIVATE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE)
-+#define DUK_HTHREAD_STRING_PRIVATE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE)
-+#define DUK_HEAP_STRING_PROTECTED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED)
-+#define DUK_HTHREAD_STRING_PROTECTED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED)
-+#define DUK_HEAP_STRING_PUBLIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC)
-+#define DUK_HTHREAD_STRING_PUBLIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC)
-+#define DUK_HEAP_STRING_STATIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC)
-+#define DUK_HTHREAD_STRING_STATIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC)
-+#define DUK_HEAP_STRING_YIELD(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD)
-+#define DUK_HTHREAD_STRING_YIELD(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD)
-+
-+#define DUK_HEAP_NUM_STRINGS                                          336
-+
-+#define DUK_STRIDX_START_RESERVED                                     291
-+#define DUK_STRIDX_START_STRICT_RESERVED                              327
-+#define DUK_STRIDX_END_RESERVED                                       336                            /* exclusive endpoint */
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128];
-+DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341];
-+#ifdef DUK_USE_BUILTIN_INITJS
-+DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187];
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_BUILTINS_DATA_LENGTH                                      1341
-+#ifdef DUK_USE_BUILTIN_INITJS
-+#define DUK_BUILTIN_INITJS_DATA_LENGTH                                187
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+
-+#define DUK_BIDX_GLOBAL                                               0
-+#define DUK_BIDX_GLOBAL_ENV                                           1
-+#define DUK_BIDX_OBJECT_CONSTRUCTOR                                   2
-+#define DUK_BIDX_OBJECT_PROTOTYPE                                     3
-+#define DUK_BIDX_FUNCTION_CONSTRUCTOR                                 4
-+#define DUK_BIDX_FUNCTION_PROTOTYPE                                   5
-+#define DUK_BIDX_ARRAY_CONSTRUCTOR                                    6
-+#define DUK_BIDX_ARRAY_PROTOTYPE                                      7
-+#define DUK_BIDX_STRING_CONSTRUCTOR                                   8
-+#define DUK_BIDX_STRING_PROTOTYPE                                     9
-+#define DUK_BIDX_BOOLEAN_CONSTRUCTOR                                  10
-+#define DUK_BIDX_BOOLEAN_PROTOTYPE                                    11
-+#define DUK_BIDX_NUMBER_CONSTRUCTOR                                   12
-+#define DUK_BIDX_NUMBER_PROTOTYPE                                     13
-+#define DUK_BIDX_DATE_CONSTRUCTOR                                     14
-+#define DUK_BIDX_DATE_PROTOTYPE                                       15
-+#define DUK_BIDX_REGEXP_CONSTRUCTOR                                   16
-+#define DUK_BIDX_REGEXP_PROTOTYPE                                     17
-+#define DUK_BIDX_ERROR_CONSTRUCTOR                                    18
-+#define DUK_BIDX_ERROR_PROTOTYPE                                      19
-+#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR                               20
-+#define DUK_BIDX_EVAL_ERROR_PROTOTYPE                                 21
-+#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR                              22
-+#define DUK_BIDX_RANGE_ERROR_PROTOTYPE                                23
-+#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR                          24
-+#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE                            25
-+#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR                             26
-+#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE                               27
-+#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR                               28
-+#define DUK_BIDX_TYPE_ERROR_PROTOTYPE                                 29
-+#define DUK_BIDX_URI_ERROR_CONSTRUCTOR                                30
-+#define DUK_BIDX_URI_ERROR_PROTOTYPE                                  31
-+#define DUK_BIDX_MATH                                                 32
-+#define DUK_BIDX_JSON                                                 33
-+#define DUK_BIDX_TYPE_ERROR_THROWER                                   34
-+#define DUK_BIDX_PROXY_CONSTRUCTOR                                    35
-+#define DUK_BIDX_DUKTAPE                                              36
-+#define DUK_BIDX_THREAD_CONSTRUCTOR                                   37
-+#define DUK_BIDX_THREAD_PROTOTYPE                                     38
-+#define DUK_BIDX_BUFFER_CONSTRUCTOR                                   39
-+#define DUK_BIDX_BUFFER_PROTOTYPE                                     40
-+#define DUK_BIDX_POINTER_CONSTRUCTOR                                  41
-+#define DUK_BIDX_POINTER_PROTOTYPE                                    42
-+#define DUK_BIDX_LOGGER_CONSTRUCTOR                                   43
-+#define DUK_BIDX_LOGGER_PROTOTYPE                                     44
-+#define DUK_BIDX_DOUBLE_ERROR                                         45
-+
-+#define DUK_NUM_BUILTINS                                              46
-+
-+#elif defined(DUK_USE_DOUBLE_ME)
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943];
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STRDATA_DATA_LENGTH                                       1943
-+#define DUK_STRDATA_MAX_STRLEN                                        24
-+
-+#define DUK_STRIDX_UC_LOGGER                                          0                              /* 'Logger' */
-+#define DUK_STRIDX_UC_THREAD                                          1                              /* 'Thread' */
-+#define DUK_STRIDX_UC_POINTER                                         2                              /* 'Pointer' */
-+#define DUK_STRIDX_UC_BUFFER                                          3                              /* 'Buffer' */
-+#define DUK_STRIDX_DEC_ENV                                            4                              /* 'DecEnv' */
-+#define DUK_STRIDX_OBJ_ENV                                            5                              /* 'ObjEnv' */
-+#define DUK_STRIDX_EMPTY_STRING                                       6                              /* '' */
-+#define DUK_STRIDX_GLOBAL                                             7                              /* 'global' */
-+#define DUK_STRIDX_UC_ARGUMENTS                                       8                              /* 'Arguments' */
-+#define DUK_STRIDX_JSON                                               9                              /* 'JSON' */
-+#define DUK_STRIDX_MATH                                               10                             /* 'Math' */
-+#define DUK_STRIDX_UC_ERROR                                           11                             /* 'Error' */
-+#define DUK_STRIDX_REG_EXP                                            12                             /* 'RegExp' */
-+#define DUK_STRIDX_DATE                                               13                             /* 'Date' */
-+#define DUK_STRIDX_UC_NUMBER                                          14                             /* 'Number' */
-+#define DUK_STRIDX_UC_BOOLEAN                                         15                             /* 'Boolean' */
-+#define DUK_STRIDX_UC_STRING                                          16                             /* 'String' */
-+#define DUK_STRIDX_ARRAY                                              17                             /* 'Array' */
-+#define DUK_STRIDX_UC_FUNCTION                                        18                             /* 'Function' */
-+#define DUK_STRIDX_UC_OBJECT                                          19                             /* 'Object' */
-+#define DUK_STRIDX_UC_NULL                                            20                             /* 'Null' */
-+#define DUK_STRIDX_UC_UNDEFINED                                       21                             /* 'Undefined' */
-+#define DUK_STRIDX_JSON_EXT_FUNCTION2                                 22                             /* '{_func:true}' */
-+#define DUK_STRIDX_JSON_EXT_FUNCTION1                                 23                             /* '{"_func":true}' */
-+#define DUK_STRIDX_JSON_EXT_NEGINF                                    24                             /* '{"_ninf":true}' */
-+#define DUK_STRIDX_JSON_EXT_POSINF                                    25                             /* '{"_inf":true}' */
-+#define DUK_STRIDX_JSON_EXT_NAN                                       26                             /* '{"_nan":true}' */
-+#define DUK_STRIDX_JSON_EXT_UNDEFINED                                 27                             /* '{"_undef":true}' */
-+#define DUK_STRIDX_TO_LOG_STRING                                      28                             /* 'toLogString' */
-+#define DUK_STRIDX_CLOG                                               29                             /* 'clog' */
-+#define DUK_STRIDX_LC_L                                               30                             /* 'l' */
-+#define DUK_STRIDX_LC_N                                               31                             /* 'n' */
-+#define DUK_STRIDX_LC_FATAL                                           32                             /* 'fatal' */
-+#define DUK_STRIDX_LC_ERROR                                           33                             /* 'error' */
-+#define DUK_STRIDX_LC_WARN                                            34                             /* 'warn' */
-+#define DUK_STRIDX_LC_DEBUG                                           35                             /* 'debug' */
-+#define DUK_STRIDX_LC_TRACE                                           36                             /* 'trace' */
-+#define DUK_STRIDX_RAW                                                37                             /* 'raw' */
-+#define DUK_STRIDX_FMT                                                38                             /* 'fmt' */
-+#define DUK_STRIDX_CURRENT                                            39                             /* 'current' */
-+#define DUK_STRIDX_RESUME                                             40                             /* 'resume' */
-+#define DUK_STRIDX_COMPACT                                            41                             /* 'compact' */
-+#define DUK_STRIDX_JC                                                 42                             /* 'jc' */
-+#define DUK_STRIDX_JX                                                 43                             /* 'jx' */
-+#define DUK_STRIDX_BASE64                                             44                             /* 'base64' */
-+#define DUK_STRIDX_HEX                                                45                             /* 'hex' */
-+#define DUK_STRIDX_DEC                                                46                             /* 'dec' */
-+#define DUK_STRIDX_ENC                                                47                             /* 'enc' */
-+#define DUK_STRIDX_FIN                                                48                             /* 'fin' */
-+#define DUK_STRIDX_GC                                                 49                             /* 'gc' */
-+#define DUK_STRIDX_ACT                                                50                             /* 'act' */
-+#define DUK_STRIDX_LC_INFO                                            51                             /* 'info' */
-+#define DUK_STRIDX_VERSION                                            52                             /* 'version' */
-+#define DUK_STRIDX_ENV                                                53                             /* 'env' */
-+#define DUK_STRIDX_MOD_LOADED                                         54                             /* 'modLoaded' */
-+#define DUK_STRIDX_MOD_SEARCH                                         55                             /* 'modSearch' */
-+#define DUK_STRIDX_ERR_THROW                                          56                             /* 'errThrow' */
-+#define DUK_STRIDX_ERR_CREATE                                         57                             /* 'errCreate' */
-+#define DUK_STRIDX_COMPILE                                            58                             /* 'compile' */
-+#define DUK_STRIDX_INT_REGBASE                                        59                             /* '\x00Regbase' */
-+#define DUK_STRIDX_INT_THREAD                                         60                             /* '\x00Thread' */
-+#define DUK_STRIDX_INT_HANDLER                                        61                             /* '\x00Handler' */
-+#define DUK_STRIDX_INT_FINALIZER                                      62                             /* '\x00Finalizer' */
-+#define DUK_STRIDX_INT_CALLEE                                         63                             /* '\x00Callee' */
-+#define DUK_STRIDX_INT_MAP                                            64                             /* '\x00Map' */
-+#define DUK_STRIDX_INT_ARGS                                           65                             /* '\x00Args' */
-+#define DUK_STRIDX_INT_THIS                                           66                             /* '\x00This' */
-+#define DUK_STRIDX_INT_PC2LINE                                        67                             /* '\x00Pc2line' */
-+#define DUK_STRIDX_INT_SOURCE                                         68                             /* '\x00Source' */
-+#define DUK_STRIDX_INT_VARENV                                         69                             /* '\x00Varenv' */
-+#define DUK_STRIDX_INT_LEXENV                                         70                             /* '\x00Lexenv' */
-+#define DUK_STRIDX_INT_VARMAP                                         71                             /* '\x00Varmap' */
-+#define DUK_STRIDX_INT_FORMALS                                        72                             /* '\x00Formals' */
-+#define DUK_STRIDX_INT_BYTECODE                                       73                             /* '\x00Bytecode' */
-+#define DUK_STRIDX_INT_NEXT                                           74                             /* '\x00Next' */
-+#define DUK_STRIDX_INT_TARGET                                         75                             /* '\x00Target' */
-+#define DUK_STRIDX_INT_VALUE                                          76                             /* '\x00Value' */
-+#define DUK_STRIDX_LC_POINTER                                         77                             /* 'pointer' */
-+#define DUK_STRIDX_LC_BUFFER                                          78                             /* 'buffer' */
-+#define DUK_STRIDX_INT_TRACEDATA                                      79                             /* '\x00Tracedata' */
-+#define DUK_STRIDX_LINE_NUMBER                                        80                             /* 'lineNumber' */
-+#define DUK_STRIDX_FILE_NAME                                          81                             /* 'fileName' */
-+#define DUK_STRIDX_PC                                                 82                             /* 'pc' */
-+#define DUK_STRIDX_STACK                                              83                             /* 'stack' */
-+#define DUK_STRIDX_THROW_TYPE_ERROR                                   84                             /* 'ThrowTypeError' */
-+#define DUK_STRIDX_DUKTAPE                                            85                             /* 'Duktape' */
-+#define DUK_STRIDX_ID                                                 86                             /* 'id' */
-+#define DUK_STRIDX_REQUIRE                                            87                             /* 'require' */
-+#define DUK_STRIDX___PROTO__                                          88                             /* '__proto__' */
-+#define DUK_STRIDX_SET_PROTOTYPE_OF                                   89                             /* 'setPrototypeOf' */
-+#define DUK_STRIDX_OWN_KEYS                                           90                             /* 'ownKeys' */
-+#define DUK_STRIDX_ENUMERATE                                          91                             /* 'enumerate' */
-+#define DUK_STRIDX_DELETE_PROPERTY                                    92                             /* 'deleteProperty' */
-+#define DUK_STRIDX_HAS                                                93                             /* 'has' */
-+#define DUK_STRIDX_PROXY                                              94                             /* 'Proxy' */
-+#define DUK_STRIDX_CALLEE                                             95                             /* 'callee' */
-+#define DUK_STRIDX_INVALID_DATE                                       96                             /* 'Invalid Date' */
-+#define DUK_STRIDX_BRACKETED_ELLIPSIS                                 97                             /* '[...]' */
-+#define DUK_STRIDX_NEWLINE_TAB                                        98                             /* '\n\t' */
-+#define DUK_STRIDX_SPACE                                              99                             /* ' ' */
-+#define DUK_STRIDX_COMMA                                              100                            /* ',' */
-+#define DUK_STRIDX_MINUS_ZERO                                         101                            /* '-0' */
-+#define DUK_STRIDX_PLUS_ZERO                                          102                            /* '+0' */
-+#define DUK_STRIDX_ZERO                                               103                            /* '0' */
-+#define DUK_STRIDX_MINUS_INFINITY                                     104                            /* '-Infinity' */
-+#define DUK_STRIDX_PLUS_INFINITY                                      105                            /* '+Infinity' */
-+#define DUK_STRIDX_INFINITY                                           106                            /* 'Infinity' */
-+#define DUK_STRIDX_LC_OBJECT                                          107                            /* 'object' */
-+#define DUK_STRIDX_LC_STRING                                          108                            /* 'string' */
-+#define DUK_STRIDX_LC_NUMBER                                          109                            /* 'number' */
-+#define DUK_STRIDX_LC_BOOLEAN                                         110                            /* 'boolean' */
-+#define DUK_STRIDX_LC_UNDEFINED                                       111                            /* 'undefined' */
-+#define DUK_STRIDX_STRINGIFY                                          112                            /* 'stringify' */
-+#define DUK_STRIDX_TAN                                                113                            /* 'tan' */
-+#define DUK_STRIDX_SQRT                                               114                            /* 'sqrt' */
-+#define DUK_STRIDX_SIN                                                115                            /* 'sin' */
-+#define DUK_STRIDX_ROUND                                              116                            /* 'round' */
-+#define DUK_STRIDX_RANDOM                                             117                            /* 'random' */
-+#define DUK_STRIDX_POW                                                118                            /* 'pow' */
-+#define DUK_STRIDX_MIN                                                119                            /* 'min' */
-+#define DUK_STRIDX_MAX                                                120                            /* 'max' */
-+#define DUK_STRIDX_LOG                                                121                            /* 'log' */
-+#define DUK_STRIDX_FLOOR                                              122                            /* 'floor' */
-+#define DUK_STRIDX_EXP                                                123                            /* 'exp' */
-+#define DUK_STRIDX_COS                                                124                            /* 'cos' */
-+#define DUK_STRIDX_CEIL                                               125                            /* 'ceil' */
-+#define DUK_STRIDX_ATAN2                                              126                            /* 'atan2' */
-+#define DUK_STRIDX_ATAN                                               127                            /* 'atan' */
-+#define DUK_STRIDX_ASIN                                               128                            /* 'asin' */
-+#define DUK_STRIDX_ACOS                                               129                            /* 'acos' */
-+#define DUK_STRIDX_ABS                                                130                            /* 'abs' */
-+#define DUK_STRIDX_SQRT2                                              131                            /* 'SQRT2' */
-+#define DUK_STRIDX_SQRT1_2                                            132                            /* 'SQRT1_2' */
-+#define DUK_STRIDX_PI                                                 133                            /* 'PI' */
-+#define DUK_STRIDX_LOG10E                                             134                            /* 'LOG10E' */
-+#define DUK_STRIDX_LOG2E                                              135                            /* 'LOG2E' */
-+#define DUK_STRIDX_LN2                                                136                            /* 'LN2' */
-+#define DUK_STRIDX_LN10                                               137                            /* 'LN10' */
-+#define DUK_STRIDX_E                                                  138                            /* 'E' */
-+#define DUK_STRIDX_MESSAGE                                            139                            /* 'message' */
-+#define DUK_STRIDX_NAME                                               140                            /* 'name' */
-+#define DUK_STRIDX_INPUT                                              141                            /* 'input' */
-+#define DUK_STRIDX_INDEX                                              142                            /* 'index' */
-+#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP                               143                            /* '(?:)' */
-+#define DUK_STRIDX_LAST_INDEX                                         144                            /* 'lastIndex' */
-+#define DUK_STRIDX_MULTILINE                                          145                            /* 'multiline' */
-+#define DUK_STRIDX_IGNORE_CASE                                        146                            /* 'ignoreCase' */
-+#define DUK_STRIDX_SOURCE                                             147                            /* 'source' */
-+#define DUK_STRIDX_TEST                                               148                            /* 'test' */
-+#define DUK_STRIDX_EXEC                                               149                            /* 'exec' */
-+#define DUK_STRIDX_TO_GMT_STRING                                      150                            /* 'toGMTString' */
-+#define DUK_STRIDX_SET_YEAR                                           151                            /* 'setYear' */
-+#define DUK_STRIDX_GET_YEAR                                           152                            /* 'getYear' */
-+#define DUK_STRIDX_TO_JSON                                            153                            /* 'toJSON' */
-+#define DUK_STRIDX_TO_ISO_STRING                                      154                            /* 'toISOString' */
-+#define DUK_STRIDX_TO_UTC_STRING                                      155                            /* 'toUTCString' */
-+#define DUK_STRIDX_SET_UTC_FULL_YEAR                                  156                            /* 'setUTCFullYear' */
-+#define DUK_STRIDX_SET_FULL_YEAR                                      157                            /* 'setFullYear' */
-+#define DUK_STRIDX_SET_UTC_MONTH                                      158                            /* 'setUTCMonth' */
-+#define DUK_STRIDX_SET_MONTH                                          159                            /* 'setMonth' */
-+#define DUK_STRIDX_SET_UTC_DATE                                       160                            /* 'setUTCDate' */
-+#define DUK_STRIDX_SET_DATE                                           161                            /* 'setDate' */
-+#define DUK_STRIDX_SET_UTC_HOURS                                      162                            /* 'setUTCHours' */
-+#define DUK_STRIDX_SET_HOURS                                          163                            /* 'setHours' */
-+#define DUK_STRIDX_SET_UTC_MINUTES                                    164                            /* 'setUTCMinutes' */
-+#define DUK_STRIDX_SET_MINUTES                                        165                            /* 'setMinutes' */
-+#define DUK_STRIDX_SET_UTC_SECONDS                                    166                            /* 'setUTCSeconds' */
-+#define DUK_STRIDX_SET_SECONDS                                        167                            /* 'setSeconds' */
-+#define DUK_STRIDX_SET_UTC_MILLISECONDS                               168                            /* 'setUTCMilliseconds' */
-+#define DUK_STRIDX_SET_MILLISECONDS                                   169                            /* 'setMilliseconds' */
-+#define DUK_STRIDX_SET_TIME                                           170                            /* 'setTime' */
-+#define DUK_STRIDX_GET_TIMEZONE_OFFSET                                171                            /* 'getTimezoneOffset' */
-+#define DUK_STRIDX_GET_UTC_MILLISECONDS                               172                            /* 'getUTCMilliseconds' */
-+#define DUK_STRIDX_GET_MILLISECONDS                                   173                            /* 'getMilliseconds' */
-+#define DUK_STRIDX_GET_UTC_SECONDS                                    174                            /* 'getUTCSeconds' */
-+#define DUK_STRIDX_GET_SECONDS                                        175                            /* 'getSeconds' */
-+#define DUK_STRIDX_GET_UTC_MINUTES                                    176                            /* 'getUTCMinutes' */
-+#define DUK_STRIDX_GET_MINUTES                                        177                            /* 'getMinutes' */
-+#define DUK_STRIDX_GET_UTC_HOURS                                      178                            /* 'getUTCHours' */
-+#define DUK_STRIDX_GET_HOURS                                          179                            /* 'getHours' */
-+#define DUK_STRIDX_GET_UTC_DAY                                        180                            /* 'getUTCDay' */
-+#define DUK_STRIDX_GET_DAY                                            181                            /* 'getDay' */
-+#define DUK_STRIDX_GET_UTC_DATE                                       182                            /* 'getUTCDate' */
-+#define DUK_STRIDX_GET_DATE                                           183                            /* 'getDate' */
-+#define DUK_STRIDX_GET_UTC_MONTH                                      184                            /* 'getUTCMonth' */
-+#define DUK_STRIDX_GET_MONTH                                          185                            /* 'getMonth' */
-+#define DUK_STRIDX_GET_UTC_FULL_YEAR                                  186                            /* 'getUTCFullYear' */
-+#define DUK_STRIDX_GET_FULL_YEAR                                      187                            /* 'getFullYear' */
-+#define DUK_STRIDX_GET_TIME                                           188                            /* 'getTime' */
-+#define DUK_STRIDX_TO_LOCALE_TIME_STRING                              189                            /* 'toLocaleTimeString' */
-+#define DUK_STRIDX_TO_LOCALE_DATE_STRING                              190                            /* 'toLocaleDateString' */
-+#define DUK_STRIDX_TO_TIME_STRING                                     191                            /* 'toTimeString' */
-+#define DUK_STRIDX_TO_DATE_STRING                                     192                            /* 'toDateString' */
-+#define DUK_STRIDX_NOW                                                193                            /* 'now' */
-+#define DUK_STRIDX_UTC                                                194                            /* 'UTC' */
-+#define DUK_STRIDX_PARSE                                              195                            /* 'parse' */
-+#define DUK_STRIDX_TO_PRECISION                                       196                            /* 'toPrecision' */
-+#define DUK_STRIDX_TO_EXPONENTIAL                                     197                            /* 'toExponential' */
-+#define DUK_STRIDX_TO_FIXED                                           198                            /* 'toFixed' */
-+#define DUK_STRIDX_POSITIVE_INFINITY                                  199                            /* 'POSITIVE_INFINITY' */
-+#define DUK_STRIDX_NEGATIVE_INFINITY                                  200                            /* 'NEGATIVE_INFINITY' */
-+#define DUK_STRIDX_NAN                                                201                            /* 'NaN' */
-+#define DUK_STRIDX_MIN_VALUE                                          202                            /* 'MIN_VALUE' */
-+#define DUK_STRIDX_MAX_VALUE                                          203                            /* 'MAX_VALUE' */
-+#define DUK_STRIDX_SUBSTR                                             204                            /* 'substr' */
-+#define DUK_STRIDX_TRIM                                               205                            /* 'trim' */
-+#define DUK_STRIDX_TO_LOCALE_UPPER_CASE                               206                            /* 'toLocaleUpperCase' */
-+#define DUK_STRIDX_TO_UPPER_CASE                                      207                            /* 'toUpperCase' */
-+#define DUK_STRIDX_TO_LOCALE_LOWER_CASE                               208                            /* 'toLocaleLowerCase' */
-+#define DUK_STRIDX_TO_LOWER_CASE                                      209                            /* 'toLowerCase' */
-+#define DUK_STRIDX_SUBSTRING                                          210                            /* 'substring' */
-+#define DUK_STRIDX_SPLIT                                              211                            /* 'split' */
-+#define DUK_STRIDX_SEARCH                                             212                            /* 'search' */
-+#define DUK_STRIDX_REPLACE                                            213                            /* 'replace' */
-+#define DUK_STRIDX_MATCH                                              214                            /* 'match' */
-+#define DUK_STRIDX_LOCALE_COMPARE                                     215                            /* 'localeCompare' */
-+#define DUK_STRIDX_CHAR_CODE_AT                                       216                            /* 'charCodeAt' */
-+#define DUK_STRIDX_CHAR_AT                                            217                            /* 'charAt' */
-+#define DUK_STRIDX_FROM_CHAR_CODE                                     218                            /* 'fromCharCode' */
-+#define DUK_STRIDX_REDUCE_RIGHT                                       219                            /* 'reduceRight' */
-+#define DUK_STRIDX_REDUCE                                             220                            /* 'reduce' */
-+#define DUK_STRIDX_FILTER                                             221                            /* 'filter' */
-+#define DUK_STRIDX_MAP                                                222                            /* 'map' */
-+#define DUK_STRIDX_FOR_EACH                                           223                            /* 'forEach' */
-+#define DUK_STRIDX_SOME                                               224                            /* 'some' */
-+#define DUK_STRIDX_EVERY                                              225                            /* 'every' */
-+#define DUK_STRIDX_LAST_INDEX_OF                                      226                            /* 'lastIndexOf' */
-+#define DUK_STRIDX_INDEX_OF                                           227                            /* 'indexOf' */
-+#define DUK_STRIDX_UNSHIFT                                            228                            /* 'unshift' */
-+#define DUK_STRIDX_SPLICE                                             229                            /* 'splice' */
-+#define DUK_STRIDX_SORT                                               230                            /* 'sort' */
-+#define DUK_STRIDX_SLICE                                              231                            /* 'slice' */
-+#define DUK_STRIDX_SHIFT                                              232                            /* 'shift' */
-+#define DUK_STRIDX_REVERSE                                            233                            /* 'reverse' */
-+#define DUK_STRIDX_PUSH                                               234                            /* 'push' */
-+#define DUK_STRIDX_POP                                                235                            /* 'pop' */
-+#define DUK_STRIDX_JOIN                                               236                            /* 'join' */
-+#define DUK_STRIDX_CONCAT                                             237                            /* 'concat' */
-+#define DUK_STRIDX_IS_ARRAY                                           238                            /* 'isArray' */
-+#define DUK_STRIDX_LC_ARGUMENTS                                       239                            /* 'arguments' */
-+#define DUK_STRIDX_CALLER                                             240                            /* 'caller' */
-+#define DUK_STRIDX_BIND                                               241                            /* 'bind' */
-+#define DUK_STRIDX_CALL                                               242                            /* 'call' */
-+#define DUK_STRIDX_APPLY                                              243                            /* 'apply' */
-+#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE                             244                            /* 'propertyIsEnumerable' */
-+#define DUK_STRIDX_IS_PROTOTYPE_OF                                    245                            /* 'isPrototypeOf' */
-+#define DUK_STRIDX_HAS_OWN_PROPERTY                                   246                            /* 'hasOwnProperty' */
-+#define DUK_STRIDX_VALUE_OF                                           247                            /* 'valueOf' */
-+#define DUK_STRIDX_TO_LOCALE_STRING                                   248                            /* 'toLocaleString' */
-+#define DUK_STRIDX_TO_STRING                                          249                            /* 'toString' */
-+#define DUK_STRIDX_CONSTRUCTOR                                        250                            /* 'constructor' */
-+#define DUK_STRIDX_SET                                                251                            /* 'set' */
-+#define DUK_STRIDX_GET                                                252                            /* 'get' */
-+#define DUK_STRIDX_ENUMERABLE                                         253                            /* 'enumerable' */
-+#define DUK_STRIDX_CONFIGURABLE                                       254                            /* 'configurable' */
-+#define DUK_STRIDX_WRITABLE                                           255                            /* 'writable' */
-+#define DUK_STRIDX_VALUE                                              256                            /* 'value' */
-+#define DUK_STRIDX_KEYS                                               257                            /* 'keys' */
-+#define DUK_STRIDX_IS_EXTENSIBLE                                      258                            /* 'isExtensible' */
-+#define DUK_STRIDX_IS_FROZEN                                          259                            /* 'isFrozen' */
-+#define DUK_STRIDX_IS_SEALED                                          260                            /* 'isSealed' */
-+#define DUK_STRIDX_PREVENT_EXTENSIONS                                 261                            /* 'preventExtensions' */
-+#define DUK_STRIDX_FREEZE                                             262                            /* 'freeze' */
-+#define DUK_STRIDX_SEAL                                               263                            /* 'seal' */
-+#define DUK_STRIDX_DEFINE_PROPERTIES                                  264                            /* 'defineProperties' */
-+#define DUK_STRIDX_DEFINE_PROPERTY                                    265                            /* 'defineProperty' */
-+#define DUK_STRIDX_CREATE                                             266                            /* 'create' */
-+#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES                             267                            /* 'getOwnPropertyNames' */
-+#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR                        268                            /* 'getOwnPropertyDescriptor' */
-+#define DUK_STRIDX_GET_PROTOTYPE_OF                                   269                            /* 'getPrototypeOf' */
-+#define DUK_STRIDX_PROTOTYPE                                          270                            /* 'prototype' */
-+#define DUK_STRIDX_LENGTH                                             271                            /* 'length' */
-+#define DUK_STRIDX_ALERT                                              272                            /* 'alert' */
-+#define DUK_STRIDX_PRINT                                              273                            /* 'print' */
-+#define DUK_STRIDX_UNESCAPE                                           274                            /* 'unescape' */
-+#define DUK_STRIDX_ESCAPE                                             275                            /* 'escape' */
-+#define DUK_STRIDX_ENCODE_URI_COMPONENT                               276                            /* 'encodeURIComponent' */
-+#define DUK_STRIDX_ENCODE_URI                                         277                            /* 'encodeURI' */
-+#define DUK_STRIDX_DECODE_URI_COMPONENT                               278                            /* 'decodeURIComponent' */
-+#define DUK_STRIDX_DECODE_URI                                         279                            /* 'decodeURI' */
-+#define DUK_STRIDX_IS_FINITE                                          280                            /* 'isFinite' */
-+#define DUK_STRIDX_IS_NAN                                             281                            /* 'isNaN' */
-+#define DUK_STRIDX_PARSE_FLOAT                                        282                            /* 'parseFloat' */
-+#define DUK_STRIDX_PARSE_INT                                          283                            /* 'parseInt' */
-+#define DUK_STRIDX_EVAL                                               284                            /* 'eval' */
-+#define DUK_STRIDX_URI_ERROR                                          285                            /* 'URIError' */
-+#define DUK_STRIDX_TYPE_ERROR                                         286                            /* 'TypeError' */
-+#define DUK_STRIDX_SYNTAX_ERROR                                       287                            /* 'SyntaxError' */
-+#define DUK_STRIDX_REFERENCE_ERROR                                    288                            /* 'ReferenceError' */
-+#define DUK_STRIDX_RANGE_ERROR                                        289                            /* 'RangeError' */
-+#define DUK_STRIDX_EVAL_ERROR                                         290                            /* 'EvalError' */
-+#define DUK_STRIDX_BREAK                                              291                            /* 'break' */
-+#define DUK_STRIDX_CASE                                               292                            /* 'case' */
-+#define DUK_STRIDX_CATCH                                              293                            /* 'catch' */
-+#define DUK_STRIDX_CONTINUE                                           294                            /* 'continue' */
-+#define DUK_STRIDX_DEBUGGER                                           295                            /* 'debugger' */
-+#define DUK_STRIDX_DEFAULT                                            296                            /* 'default' */
-+#define DUK_STRIDX_DELETE                                             297                            /* 'delete' */
-+#define DUK_STRIDX_DO                                                 298                            /* 'do' */
-+#define DUK_STRIDX_ELSE                                               299                            /* 'else' */
-+#define DUK_STRIDX_FINALLY                                            300                            /* 'finally' */
-+#define DUK_STRIDX_FOR                                                301                            /* 'for' */
-+#define DUK_STRIDX_LC_FUNCTION                                        302                            /* 'function' */
-+#define DUK_STRIDX_IF                                                 303                            /* 'if' */
-+#define DUK_STRIDX_IN                                                 304                            /* 'in' */
-+#define DUK_STRIDX_INSTANCEOF                                         305                            /* 'instanceof' */
-+#define DUK_STRIDX_NEW                                                306                            /* 'new' */
-+#define DUK_STRIDX_RETURN                                             307                            /* 'return' */
-+#define DUK_STRIDX_SWITCH                                             308                            /* 'switch' */
-+#define DUK_STRIDX_THIS                                               309                            /* 'this' */
-+#define DUK_STRIDX_THROW                                              310                            /* 'throw' */
-+#define DUK_STRIDX_TRY                                                311                            /* 'try' */
-+#define DUK_STRIDX_TYPEOF                                             312                            /* 'typeof' */
-+#define DUK_STRIDX_VAR                                                313                            /* 'var' */
-+#define DUK_STRIDX_VOID                                               314                            /* 'void' */
-+#define DUK_STRIDX_WHILE                                              315                            /* 'while' */
-+#define DUK_STRIDX_WITH                                               316                            /* 'with' */
-+#define DUK_STRIDX_CLASS                                              317                            /* 'class' */
-+#define DUK_STRIDX_CONST                                              318                            /* 'const' */
-+#define DUK_STRIDX_ENUM                                               319                            /* 'enum' */
-+#define DUK_STRIDX_EXPORT                                             320                            /* 'export' */
-+#define DUK_STRIDX_EXTENDS                                            321                            /* 'extends' */
-+#define DUK_STRIDX_IMPORT                                             322                            /* 'import' */
-+#define DUK_STRIDX_SUPER                                              323                            /* 'super' */
-+#define DUK_STRIDX_LC_NULL                                            324                            /* 'null' */
-+#define DUK_STRIDX_TRUE                                               325                            /* 'true' */
-+#define DUK_STRIDX_FALSE                                              326                            /* 'false' */
-+#define DUK_STRIDX_IMPLEMENTS                                         327                            /* 'implements' */
-+#define DUK_STRIDX_INTERFACE                                          328                            /* 'interface' */
-+#define DUK_STRIDX_LET                                                329                            /* 'let' */
-+#define DUK_STRIDX_PACKAGE                                            330                            /* 'package' */
-+#define DUK_STRIDX_PRIVATE                                            331                            /* 'private' */
-+#define DUK_STRIDX_PROTECTED                                          332                            /* 'protected' */
-+#define DUK_STRIDX_PUBLIC                                             333                            /* 'public' */
-+#define DUK_STRIDX_STATIC                                             334                            /* 'static' */
-+#define DUK_STRIDX_YIELD                                              335                            /* 'yield' */
-+
-+#define DUK_HEAP_STRING_UC_LOGGER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER)
-+#define DUK_HTHREAD_STRING_UC_LOGGER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER)
-+#define DUK_HEAP_STRING_UC_THREAD(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD)
-+#define DUK_HTHREAD_STRING_UC_THREAD(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD)
-+#define DUK_HEAP_STRING_UC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER)
-+#define DUK_HTHREAD_STRING_UC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER)
-+#define DUK_HEAP_STRING_UC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER)
-+#define DUK_HTHREAD_STRING_UC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER)
-+#define DUK_HEAP_STRING_DEC_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV)
-+#define DUK_HTHREAD_STRING_DEC_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV)
-+#define DUK_HEAP_STRING_OBJ_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV)
-+#define DUK_HTHREAD_STRING_OBJ_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV)
-+#define DUK_HEAP_STRING_EMPTY_STRING(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING)
-+#define DUK_HTHREAD_STRING_EMPTY_STRING(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING)
-+#define DUK_HEAP_STRING_GLOBAL(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL)
-+#define DUK_HTHREAD_STRING_GLOBAL(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL)
-+#define DUK_HEAP_STRING_UC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS)
-+#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS)
-+#define DUK_HEAP_STRING_JSON(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON)
-+#define DUK_HTHREAD_STRING_JSON(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON)
-+#define DUK_HEAP_STRING_MATH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH)
-+#define DUK_HTHREAD_STRING_MATH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH)
-+#define DUK_HEAP_STRING_UC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR)
-+#define DUK_HTHREAD_STRING_UC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR)
-+#define DUK_HEAP_STRING_REG_EXP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP)
-+#define DUK_HTHREAD_STRING_REG_EXP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP)
-+#define DUK_HEAP_STRING_DATE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE)
-+#define DUK_HTHREAD_STRING_DATE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE)
-+#define DUK_HEAP_STRING_UC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER)
-+#define DUK_HTHREAD_STRING_UC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER)
-+#define DUK_HEAP_STRING_UC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN)
-+#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN)
-+#define DUK_HEAP_STRING_UC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING)
-+#define DUK_HTHREAD_STRING_UC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING)
-+#define DUK_HEAP_STRING_ARRAY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY)
-+#define DUK_HTHREAD_STRING_ARRAY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY)
-+#define DUK_HEAP_STRING_UC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION)
-+#define DUK_HTHREAD_STRING_UC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION)
-+#define DUK_HEAP_STRING_UC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT)
-+#define DUK_HTHREAD_STRING_UC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT)
-+#define DUK_HEAP_STRING_UC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL)
-+#define DUK_HTHREAD_STRING_UC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL)
-+#define DUK_HEAP_STRING_UC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED)
-+#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED)
-+#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2)
-+#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2)
-+#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1)
-+#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1)
-+#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF)
-+#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF)
-+#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF)
-+#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF)
-+#define DUK_HEAP_STRING_JSON_EXT_NAN(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN)
-+#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN)
-+#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED)
-+#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED)
-+#define DUK_HEAP_STRING_TO_LOG_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING)
-+#define DUK_HEAP_STRING_CLOG(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG)
-+#define DUK_HTHREAD_STRING_CLOG(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG)
-+#define DUK_HEAP_STRING_LC_L(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L)
-+#define DUK_HTHREAD_STRING_LC_L(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L)
-+#define DUK_HEAP_STRING_LC_N(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N)
-+#define DUK_HTHREAD_STRING_LC_N(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N)
-+#define DUK_HEAP_STRING_LC_FATAL(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL)
-+#define DUK_HTHREAD_STRING_LC_FATAL(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL)
-+#define DUK_HEAP_STRING_LC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR)
-+#define DUK_HTHREAD_STRING_LC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR)
-+#define DUK_HEAP_STRING_LC_WARN(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN)
-+#define DUK_HTHREAD_STRING_LC_WARN(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN)
-+#define DUK_HEAP_STRING_LC_DEBUG(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG)
-+#define DUK_HTHREAD_STRING_LC_DEBUG(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG)
-+#define DUK_HEAP_STRING_LC_TRACE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE)
-+#define DUK_HTHREAD_STRING_LC_TRACE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE)
-+#define DUK_HEAP_STRING_RAW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW)
-+#define DUK_HTHREAD_STRING_RAW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW)
-+#define DUK_HEAP_STRING_FMT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT)
-+#define DUK_HTHREAD_STRING_FMT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT)
-+#define DUK_HEAP_STRING_CURRENT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT)
-+#define DUK_HTHREAD_STRING_CURRENT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT)
-+#define DUK_HEAP_STRING_RESUME(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME)
-+#define DUK_HTHREAD_STRING_RESUME(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME)
-+#define DUK_HEAP_STRING_COMPACT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT)
-+#define DUK_HTHREAD_STRING_COMPACT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT)
-+#define DUK_HEAP_STRING_JC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC)
-+#define DUK_HTHREAD_STRING_JC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC)
-+#define DUK_HEAP_STRING_JX(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX)
-+#define DUK_HTHREAD_STRING_JX(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX)
-+#define DUK_HEAP_STRING_BASE64(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64)
-+#define DUK_HTHREAD_STRING_BASE64(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64)
-+#define DUK_HEAP_STRING_HEX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX)
-+#define DUK_HTHREAD_STRING_HEX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX)
-+#define DUK_HEAP_STRING_DEC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC)
-+#define DUK_HTHREAD_STRING_DEC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC)
-+#define DUK_HEAP_STRING_ENC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC)
-+#define DUK_HTHREAD_STRING_ENC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC)
-+#define DUK_HEAP_STRING_FIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN)
-+#define DUK_HTHREAD_STRING_FIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN)
-+#define DUK_HEAP_STRING_GC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC)
-+#define DUK_HTHREAD_STRING_GC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC)
-+#define DUK_HEAP_STRING_ACT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT)
-+#define DUK_HTHREAD_STRING_ACT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT)
-+#define DUK_HEAP_STRING_LC_INFO(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO)
-+#define DUK_HTHREAD_STRING_LC_INFO(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO)
-+#define DUK_HEAP_STRING_VERSION(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION)
-+#define DUK_HTHREAD_STRING_VERSION(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION)
-+#define DUK_HEAP_STRING_ENV(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV)
-+#define DUK_HTHREAD_STRING_ENV(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV)
-+#define DUK_HEAP_STRING_MOD_LOADED(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED)
-+#define DUK_HTHREAD_STRING_MOD_LOADED(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED)
-+#define DUK_HEAP_STRING_MOD_SEARCH(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH)
-+#define DUK_HTHREAD_STRING_MOD_SEARCH(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH)
-+#define DUK_HEAP_STRING_ERR_THROW(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW)
-+#define DUK_HTHREAD_STRING_ERR_THROW(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW)
-+#define DUK_HEAP_STRING_ERR_CREATE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE)
-+#define DUK_HTHREAD_STRING_ERR_CREATE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE)
-+#define DUK_HEAP_STRING_COMPILE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE)
-+#define DUK_HTHREAD_STRING_COMPILE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE)
-+#define DUK_HEAP_STRING_INT_REGBASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE)
-+#define DUK_HTHREAD_STRING_INT_REGBASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE)
-+#define DUK_HEAP_STRING_INT_THREAD(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD)
-+#define DUK_HTHREAD_STRING_INT_THREAD(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD)
-+#define DUK_HEAP_STRING_INT_HANDLER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER)
-+#define DUK_HTHREAD_STRING_INT_HANDLER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER)
-+#define DUK_HEAP_STRING_INT_FINALIZER(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER)
-+#define DUK_HTHREAD_STRING_INT_FINALIZER(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER)
-+#define DUK_HEAP_STRING_INT_CALLEE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE)
-+#define DUK_HTHREAD_STRING_INT_CALLEE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE)
-+#define DUK_HEAP_STRING_INT_MAP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP)
-+#define DUK_HTHREAD_STRING_INT_MAP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP)
-+#define DUK_HEAP_STRING_INT_ARGS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS)
-+#define DUK_HTHREAD_STRING_INT_ARGS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS)
-+#define DUK_HEAP_STRING_INT_THIS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS)
-+#define DUK_HTHREAD_STRING_INT_THIS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS)
-+#define DUK_HEAP_STRING_INT_PC2LINE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE)
-+#define DUK_HTHREAD_STRING_INT_PC2LINE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE)
-+#define DUK_HEAP_STRING_INT_SOURCE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE)
-+#define DUK_HTHREAD_STRING_INT_SOURCE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE)
-+#define DUK_HEAP_STRING_INT_VARENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV)
-+#define DUK_HTHREAD_STRING_INT_VARENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV)
-+#define DUK_HEAP_STRING_INT_LEXENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV)
-+#define DUK_HTHREAD_STRING_INT_LEXENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV)
-+#define DUK_HEAP_STRING_INT_VARMAP(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP)
-+#define DUK_HTHREAD_STRING_INT_VARMAP(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP)
-+#define DUK_HEAP_STRING_INT_FORMALS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS)
-+#define DUK_HTHREAD_STRING_INT_FORMALS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS)
-+#define DUK_HEAP_STRING_INT_BYTECODE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE)
-+#define DUK_HTHREAD_STRING_INT_BYTECODE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE)
-+#define DUK_HEAP_STRING_INT_NEXT(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT)
-+#define DUK_HTHREAD_STRING_INT_NEXT(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT)
-+#define DUK_HEAP_STRING_INT_TARGET(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET)
-+#define DUK_HTHREAD_STRING_INT_TARGET(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET)
-+#define DUK_HEAP_STRING_INT_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE)
-+#define DUK_HTHREAD_STRING_INT_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE)
-+#define DUK_HEAP_STRING_LC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER)
-+#define DUK_HTHREAD_STRING_LC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER)
-+#define DUK_HEAP_STRING_LC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER)
-+#define DUK_HTHREAD_STRING_LC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER)
-+#define DUK_HEAP_STRING_INT_TRACEDATA(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA)
-+#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA)
-+#define DUK_HEAP_STRING_LINE_NUMBER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER)
-+#define DUK_HTHREAD_STRING_LINE_NUMBER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER)
-+#define DUK_HEAP_STRING_FILE_NAME(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME)
-+#define DUK_HTHREAD_STRING_FILE_NAME(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME)
-+#define DUK_HEAP_STRING_PC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC)
-+#define DUK_HTHREAD_STRING_PC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC)
-+#define DUK_HEAP_STRING_STACK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK)
-+#define DUK_HTHREAD_STRING_STACK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK)
-+#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR)
-+#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR)
-+#define DUK_HEAP_STRING_DUKTAPE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE)
-+#define DUK_HTHREAD_STRING_DUKTAPE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE)
-+#define DUK_HEAP_STRING_ID(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID)
-+#define DUK_HTHREAD_STRING_ID(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID)
-+#define DUK_HEAP_STRING_REQUIRE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE)
-+#define DUK_HTHREAD_STRING_REQUIRE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE)
-+#define DUK_HEAP_STRING___PROTO__(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__)
-+#define DUK_HTHREAD_STRING___PROTO__(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__)
-+#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_OWN_KEYS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS)
-+#define DUK_HTHREAD_STRING_OWN_KEYS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS)
-+#define DUK_HEAP_STRING_ENUMERATE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE)
-+#define DUK_HTHREAD_STRING_ENUMERATE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE)
-+#define DUK_HEAP_STRING_DELETE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY)
-+#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY)
-+#define DUK_HEAP_STRING_HAS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS)
-+#define DUK_HTHREAD_STRING_HAS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS)
-+#define DUK_HEAP_STRING_PROXY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY)
-+#define DUK_HTHREAD_STRING_PROXY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY)
-+#define DUK_HEAP_STRING_CALLEE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE)
-+#define DUK_HTHREAD_STRING_CALLEE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE)
-+#define DUK_HEAP_STRING_INVALID_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE)
-+#define DUK_HTHREAD_STRING_INVALID_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE)
-+#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS)
-+#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS)
-+#define DUK_HEAP_STRING_NEWLINE_TAB(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB)
-+#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB)
-+#define DUK_HEAP_STRING_SPACE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE)
-+#define DUK_HTHREAD_STRING_SPACE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE)
-+#define DUK_HEAP_STRING_COMMA(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA)
-+#define DUK_HTHREAD_STRING_COMMA(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA)
-+#define DUK_HEAP_STRING_MINUS_ZERO(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO)
-+#define DUK_HTHREAD_STRING_MINUS_ZERO(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO)
-+#define DUK_HEAP_STRING_PLUS_ZERO(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO)
-+#define DUK_HTHREAD_STRING_PLUS_ZERO(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO)
-+#define DUK_HEAP_STRING_ZERO(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO)
-+#define DUK_HTHREAD_STRING_ZERO(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO)
-+#define DUK_HEAP_STRING_MINUS_INFINITY(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY)
-+#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY)
-+#define DUK_HEAP_STRING_PLUS_INFINITY(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY)
-+#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY)
-+#define DUK_HEAP_STRING_INFINITY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY)
-+#define DUK_HTHREAD_STRING_INFINITY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY)
-+#define DUK_HEAP_STRING_LC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT)
-+#define DUK_HTHREAD_STRING_LC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT)
-+#define DUK_HEAP_STRING_LC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING)
-+#define DUK_HTHREAD_STRING_LC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING)
-+#define DUK_HEAP_STRING_LC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER)
-+#define DUK_HTHREAD_STRING_LC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER)
-+#define DUK_HEAP_STRING_LC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN)
-+#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN)
-+#define DUK_HEAP_STRING_LC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED)
-+#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED)
-+#define DUK_HEAP_STRING_STRINGIFY(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY)
-+#define DUK_HTHREAD_STRING_STRINGIFY(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY)
-+#define DUK_HEAP_STRING_TAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN)
-+#define DUK_HTHREAD_STRING_TAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN)
-+#define DUK_HEAP_STRING_SQRT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT)
-+#define DUK_HTHREAD_STRING_SQRT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT)
-+#define DUK_HEAP_STRING_SIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN)
-+#define DUK_HTHREAD_STRING_SIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN)
-+#define DUK_HEAP_STRING_ROUND(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND)
-+#define DUK_HTHREAD_STRING_ROUND(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND)
-+#define DUK_HEAP_STRING_RANDOM(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM)
-+#define DUK_HTHREAD_STRING_RANDOM(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM)
-+#define DUK_HEAP_STRING_POW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW)
-+#define DUK_HTHREAD_STRING_POW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW)
-+#define DUK_HEAP_STRING_MIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN)
-+#define DUK_HTHREAD_STRING_MIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN)
-+#define DUK_HEAP_STRING_MAX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX)
-+#define DUK_HTHREAD_STRING_MAX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX)
-+#define DUK_HEAP_STRING_LOG(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG)
-+#define DUK_HTHREAD_STRING_LOG(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG)
-+#define DUK_HEAP_STRING_FLOOR(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR)
-+#define DUK_HTHREAD_STRING_FLOOR(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR)
-+#define DUK_HEAP_STRING_EXP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP)
-+#define DUK_HTHREAD_STRING_EXP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP)
-+#define DUK_HEAP_STRING_COS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS)
-+#define DUK_HTHREAD_STRING_COS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS)
-+#define DUK_HEAP_STRING_CEIL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL)
-+#define DUK_HTHREAD_STRING_CEIL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL)
-+#define DUK_HEAP_STRING_ATAN2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2)
-+#define DUK_HTHREAD_STRING_ATAN2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2)
-+#define DUK_HEAP_STRING_ATAN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN)
-+#define DUK_HTHREAD_STRING_ATAN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN)
-+#define DUK_HEAP_STRING_ASIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN)
-+#define DUK_HTHREAD_STRING_ASIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN)
-+#define DUK_HEAP_STRING_ACOS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS)
-+#define DUK_HTHREAD_STRING_ACOS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS)
-+#define DUK_HEAP_STRING_ABS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS)
-+#define DUK_HTHREAD_STRING_ABS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS)
-+#define DUK_HEAP_STRING_SQRT2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2)
-+#define DUK_HTHREAD_STRING_SQRT2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2)
-+#define DUK_HEAP_STRING_SQRT1_2(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2)
-+#define DUK_HTHREAD_STRING_SQRT1_2(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2)
-+#define DUK_HEAP_STRING_PI(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI)
-+#define DUK_HTHREAD_STRING_PI(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI)
-+#define DUK_HEAP_STRING_LOG10E(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E)
-+#define DUK_HTHREAD_STRING_LOG10E(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E)
-+#define DUK_HEAP_STRING_LOG2E(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E)
-+#define DUK_HTHREAD_STRING_LOG2E(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E)
-+#define DUK_HEAP_STRING_LN2(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2)
-+#define DUK_HTHREAD_STRING_LN2(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2)
-+#define DUK_HEAP_STRING_LN10(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10)
-+#define DUK_HTHREAD_STRING_LN10(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10)
-+#define DUK_HEAP_STRING_E(heap)                                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E)
-+#define DUK_HTHREAD_STRING_E(thr)                                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E)
-+#define DUK_HEAP_STRING_MESSAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE)
-+#define DUK_HTHREAD_STRING_MESSAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE)
-+#define DUK_HEAP_STRING_NAME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME)
-+#define DUK_HTHREAD_STRING_NAME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME)
-+#define DUK_HEAP_STRING_INPUT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT)
-+#define DUK_HTHREAD_STRING_INPUT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT)
-+#define DUK_HEAP_STRING_INDEX(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX)
-+#define DUK_HTHREAD_STRING_INDEX(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX)
-+#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
-+#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
-+#define DUK_HEAP_STRING_LAST_INDEX(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX)
-+#define DUK_HTHREAD_STRING_LAST_INDEX(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX)
-+#define DUK_HEAP_STRING_MULTILINE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE)
-+#define DUK_HTHREAD_STRING_MULTILINE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE)
-+#define DUK_HEAP_STRING_IGNORE_CASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE)
-+#define DUK_HTHREAD_STRING_IGNORE_CASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE)
-+#define DUK_HEAP_STRING_SOURCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE)
-+#define DUK_HTHREAD_STRING_SOURCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE)
-+#define DUK_HEAP_STRING_TEST(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST)
-+#define DUK_HTHREAD_STRING_TEST(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST)
-+#define DUK_HEAP_STRING_EXEC(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC)
-+#define DUK_HTHREAD_STRING_EXEC(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC)
-+#define DUK_HEAP_STRING_TO_GMT_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING)
-+#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING)
-+#define DUK_HEAP_STRING_SET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR)
-+#define DUK_HTHREAD_STRING_SET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR)
-+#define DUK_HEAP_STRING_GET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR)
-+#define DUK_HTHREAD_STRING_GET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR)
-+#define DUK_HEAP_STRING_TO_JSON(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON)
-+#define DUK_HTHREAD_STRING_TO_JSON(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON)
-+#define DUK_HEAP_STRING_TO_ISO_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING)
-+#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING)
-+#define DUK_HEAP_STRING_TO_UTC_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING)
-+#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING)
-+#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR)
-+#define DUK_HEAP_STRING_SET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR)
-+#define DUK_HEAP_STRING_SET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH)
-+#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH)
-+#define DUK_HEAP_STRING_SET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH)
-+#define DUK_HTHREAD_STRING_SET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH)
-+#define DUK_HEAP_STRING_SET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE)
-+#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE)
-+#define DUK_HEAP_STRING_SET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE)
-+#define DUK_HTHREAD_STRING_SET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE)
-+#define DUK_HEAP_STRING_SET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS)
-+#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS)
-+#define DUK_HEAP_STRING_SET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS)
-+#define DUK_HTHREAD_STRING_SET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS)
-+#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES)
-+#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES)
-+#define DUK_HEAP_STRING_SET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES)
-+#define DUK_HTHREAD_STRING_SET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES)
-+#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS)
-+#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS)
-+#define DUK_HEAP_STRING_SET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS)
-+#define DUK_HTHREAD_STRING_SET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS)
-+#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS)
-+#define DUK_HEAP_STRING_SET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS)
-+#define DUK_HEAP_STRING_SET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME)
-+#define DUK_HTHREAD_STRING_SET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME)
-+#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap)                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET)
-+#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr)                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET)
-+#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS)
-+#define DUK_HEAP_STRING_GET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS)
-+#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS)
-+#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS)
-+#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS)
-+#define DUK_HEAP_STRING_GET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS)
-+#define DUK_HTHREAD_STRING_GET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS)
-+#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES)
-+#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES)
-+#define DUK_HEAP_STRING_GET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES)
-+#define DUK_HTHREAD_STRING_GET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES)
-+#define DUK_HEAP_STRING_GET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS)
-+#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS)
-+#define DUK_HEAP_STRING_GET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS)
-+#define DUK_HTHREAD_STRING_GET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS)
-+#define DUK_HEAP_STRING_GET_UTC_DAY(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY)
-+#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY)
-+#define DUK_HEAP_STRING_GET_DAY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY)
-+#define DUK_HTHREAD_STRING_GET_DAY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY)
-+#define DUK_HEAP_STRING_GET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE)
-+#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE)
-+#define DUK_HEAP_STRING_GET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE)
-+#define DUK_HTHREAD_STRING_GET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE)
-+#define DUK_HEAP_STRING_GET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH)
-+#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH)
-+#define DUK_HEAP_STRING_GET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH)
-+#define DUK_HTHREAD_STRING_GET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH)
-+#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR)
-+#define DUK_HEAP_STRING_GET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR)
-+#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR)
-+#define DUK_HEAP_STRING_GET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME)
-+#define DUK_HTHREAD_STRING_GET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME)
-+#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING)
-+#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING)
-+#define DUK_HEAP_STRING_TO_TIME_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING)
-+#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING)
-+#define DUK_HEAP_STRING_TO_DATE_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING)
-+#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING)
-+#define DUK_HEAP_STRING_NOW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW)
-+#define DUK_HTHREAD_STRING_NOW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW)
-+#define DUK_HEAP_STRING_UTC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC)
-+#define DUK_HTHREAD_STRING_UTC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC)
-+#define DUK_HEAP_STRING_PARSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE)
-+#define DUK_HTHREAD_STRING_PARSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE)
-+#define DUK_HEAP_STRING_TO_PRECISION(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION)
-+#define DUK_HTHREAD_STRING_TO_PRECISION(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION)
-+#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL)
-+#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL)
-+#define DUK_HEAP_STRING_TO_FIXED(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED)
-+#define DUK_HTHREAD_STRING_TO_FIXED(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED)
-+#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY)
-+#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY)
-+#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY)
-+#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY)
-+#define DUK_HEAP_STRING_NAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN)
-+#define DUK_HTHREAD_STRING_NAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN)
-+#define DUK_HEAP_STRING_MIN_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE)
-+#define DUK_HTHREAD_STRING_MIN_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE)
-+#define DUK_HEAP_STRING_MAX_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE)
-+#define DUK_HTHREAD_STRING_MAX_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE)
-+#define DUK_HEAP_STRING_SUBSTR(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR)
-+#define DUK_HTHREAD_STRING_SUBSTR(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR)
-+#define DUK_HEAP_STRING_TRIM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM)
-+#define DUK_HTHREAD_STRING_TRIM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM)
-+#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
-+#define DUK_HEAP_STRING_TO_UPPER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE)
-+#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE)
-+#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
-+#define DUK_HEAP_STRING_TO_LOWER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE)
-+#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE)
-+#define DUK_HEAP_STRING_SUBSTRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING)
-+#define DUK_HTHREAD_STRING_SUBSTRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING)
-+#define DUK_HEAP_STRING_SPLIT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT)
-+#define DUK_HTHREAD_STRING_SPLIT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT)
-+#define DUK_HEAP_STRING_SEARCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH)
-+#define DUK_HTHREAD_STRING_SEARCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH)
-+#define DUK_HEAP_STRING_REPLACE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE)
-+#define DUK_HTHREAD_STRING_REPLACE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE)
-+#define DUK_HEAP_STRING_MATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH)
-+#define DUK_HTHREAD_STRING_MATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH)
-+#define DUK_HEAP_STRING_LOCALE_COMPARE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE)
-+#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE)
-+#define DUK_HEAP_STRING_CHAR_CODE_AT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT)
-+#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT)
-+#define DUK_HEAP_STRING_CHAR_AT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT)
-+#define DUK_HTHREAD_STRING_CHAR_AT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT)
-+#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE)
-+#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE)
-+#define DUK_HEAP_STRING_REDUCE_RIGHT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT)
-+#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT)
-+#define DUK_HEAP_STRING_REDUCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE)
-+#define DUK_HTHREAD_STRING_REDUCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE)
-+#define DUK_HEAP_STRING_FILTER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER)
-+#define DUK_HTHREAD_STRING_FILTER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER)
-+#define DUK_HEAP_STRING_MAP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP)
-+#define DUK_HTHREAD_STRING_MAP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP)
-+#define DUK_HEAP_STRING_FOR_EACH(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH)
-+#define DUK_HTHREAD_STRING_FOR_EACH(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH)
-+#define DUK_HEAP_STRING_SOME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME)
-+#define DUK_HTHREAD_STRING_SOME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME)
-+#define DUK_HEAP_STRING_EVERY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY)
-+#define DUK_HTHREAD_STRING_EVERY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY)
-+#define DUK_HEAP_STRING_LAST_INDEX_OF(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF)
-+#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF)
-+#define DUK_HEAP_STRING_INDEX_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF)
-+#define DUK_HTHREAD_STRING_INDEX_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF)
-+#define DUK_HEAP_STRING_UNSHIFT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT)
-+#define DUK_HTHREAD_STRING_UNSHIFT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT)
-+#define DUK_HEAP_STRING_SPLICE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE)
-+#define DUK_HTHREAD_STRING_SPLICE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE)
-+#define DUK_HEAP_STRING_SORT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT)
-+#define DUK_HTHREAD_STRING_SORT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT)
-+#define DUK_HEAP_STRING_SLICE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE)
-+#define DUK_HTHREAD_STRING_SLICE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE)
-+#define DUK_HEAP_STRING_SHIFT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT)
-+#define DUK_HTHREAD_STRING_SHIFT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT)
-+#define DUK_HEAP_STRING_REVERSE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE)
-+#define DUK_HTHREAD_STRING_REVERSE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE)
-+#define DUK_HEAP_STRING_PUSH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH)
-+#define DUK_HTHREAD_STRING_PUSH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH)
-+#define DUK_HEAP_STRING_POP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP)
-+#define DUK_HTHREAD_STRING_POP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP)
-+#define DUK_HEAP_STRING_JOIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN)
-+#define DUK_HTHREAD_STRING_JOIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN)
-+#define DUK_HEAP_STRING_CONCAT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT)
-+#define DUK_HTHREAD_STRING_CONCAT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT)
-+#define DUK_HEAP_STRING_IS_ARRAY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY)
-+#define DUK_HTHREAD_STRING_IS_ARRAY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY)
-+#define DUK_HEAP_STRING_LC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS)
-+#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)
-+#define DUK_HEAP_STRING_CALLER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER)
-+#define DUK_HTHREAD_STRING_CALLER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER)
-+#define DUK_HEAP_STRING_BIND(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND)
-+#define DUK_HTHREAD_STRING_BIND(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND)
-+#define DUK_HEAP_STRING_CALL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL)
-+#define DUK_HTHREAD_STRING_CALL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL)
-+#define DUK_HEAP_STRING_APPLY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY)
-+#define DUK_HTHREAD_STRING_APPLY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY)
-+#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
-+#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
-+#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY)
-+#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY)
-+#define DUK_HEAP_STRING_VALUE_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF)
-+#define DUK_HTHREAD_STRING_VALUE_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF)
-+#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING)
-+#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING)
-+#define DUK_HEAP_STRING_TO_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING)
-+#define DUK_HTHREAD_STRING_TO_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING)
-+#define DUK_HEAP_STRING_CONSTRUCTOR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR)
-+#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR)
-+#define DUK_HEAP_STRING_SET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET)
-+#define DUK_HTHREAD_STRING_SET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET)
-+#define DUK_HEAP_STRING_GET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET)
-+#define DUK_HTHREAD_STRING_GET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET)
-+#define DUK_HEAP_STRING_ENUMERABLE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE)
-+#define DUK_HTHREAD_STRING_ENUMERABLE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE)
-+#define DUK_HEAP_STRING_CONFIGURABLE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE)
-+#define DUK_HTHREAD_STRING_CONFIGURABLE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE)
-+#define DUK_HEAP_STRING_WRITABLE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE)
-+#define DUK_HTHREAD_STRING_WRITABLE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE)
-+#define DUK_HEAP_STRING_VALUE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE)
-+#define DUK_HTHREAD_STRING_VALUE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE)
-+#define DUK_HEAP_STRING_KEYS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS)
-+#define DUK_HTHREAD_STRING_KEYS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS)
-+#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE)
-+#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE)
-+#define DUK_HEAP_STRING_IS_FROZEN(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN)
-+#define DUK_HTHREAD_STRING_IS_FROZEN(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN)
-+#define DUK_HEAP_STRING_IS_SEALED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED)
-+#define DUK_HTHREAD_STRING_IS_SEALED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED)
-+#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS)
-+#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS)
-+#define DUK_HEAP_STRING_FREEZE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE)
-+#define DUK_HTHREAD_STRING_FREEZE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE)
-+#define DUK_HEAP_STRING_SEAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL)
-+#define DUK_HTHREAD_STRING_SEAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL)
-+#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES)
-+#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES)
-+#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY)
-+#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY)
-+#define DUK_HEAP_STRING_CREATE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE)
-+#define DUK_HTHREAD_STRING_CREATE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE)
-+#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
-+#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
-+#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap)             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
-+#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr)           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
-+#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF)
-+#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF)
-+#define DUK_HEAP_STRING_PROTOTYPE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE)
-+#define DUK_HTHREAD_STRING_PROTOTYPE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE)
-+#define DUK_HEAP_STRING_LENGTH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH)
-+#define DUK_HTHREAD_STRING_LENGTH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)
-+#define DUK_HEAP_STRING_ALERT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT)
-+#define DUK_HTHREAD_STRING_ALERT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT)
-+#define DUK_HEAP_STRING_PRINT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT)
-+#define DUK_HTHREAD_STRING_PRINT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT)
-+#define DUK_HEAP_STRING_UNESCAPE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE)
-+#define DUK_HTHREAD_STRING_UNESCAPE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE)
-+#define DUK_HEAP_STRING_ESCAPE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE)
-+#define DUK_HTHREAD_STRING_ESCAPE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE)
-+#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT)
-+#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT)
-+#define DUK_HEAP_STRING_ENCODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI)
-+#define DUK_HTHREAD_STRING_ENCODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI)
-+#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT)
-+#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT)
-+#define DUK_HEAP_STRING_DECODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI)
-+#define DUK_HTHREAD_STRING_DECODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI)
-+#define DUK_HEAP_STRING_IS_FINITE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE)
-+#define DUK_HTHREAD_STRING_IS_FINITE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE)
-+#define DUK_HEAP_STRING_IS_NAN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN)
-+#define DUK_HTHREAD_STRING_IS_NAN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN)
-+#define DUK_HEAP_STRING_PARSE_FLOAT(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT)
-+#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT)
-+#define DUK_HEAP_STRING_PARSE_INT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT)
-+#define DUK_HTHREAD_STRING_PARSE_INT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT)
-+#define DUK_HEAP_STRING_EVAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL)
-+#define DUK_HTHREAD_STRING_EVAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL)
-+#define DUK_HEAP_STRING_URI_ERROR(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR)
-+#define DUK_HTHREAD_STRING_URI_ERROR(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR)
-+#define DUK_HEAP_STRING_TYPE_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR)
-+#define DUK_HTHREAD_STRING_TYPE_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR)
-+#define DUK_HEAP_STRING_SYNTAX_ERROR(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR)
-+#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR)
-+#define DUK_HEAP_STRING_REFERENCE_ERROR(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR)
-+#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR)
-+#define DUK_HEAP_STRING_RANGE_ERROR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR)
-+#define DUK_HTHREAD_STRING_RANGE_ERROR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR)
-+#define DUK_HEAP_STRING_EVAL_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR)
-+#define DUK_HTHREAD_STRING_EVAL_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR)
-+#define DUK_HEAP_STRING_BREAK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK)
-+#define DUK_HTHREAD_STRING_BREAK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK)
-+#define DUK_HEAP_STRING_CASE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE)
-+#define DUK_HTHREAD_STRING_CASE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE)
-+#define DUK_HEAP_STRING_CATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH)
-+#define DUK_HTHREAD_STRING_CATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH)
-+#define DUK_HEAP_STRING_CONTINUE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE)
-+#define DUK_HTHREAD_STRING_CONTINUE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE)
-+#define DUK_HEAP_STRING_DEBUGGER(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER)
-+#define DUK_HTHREAD_STRING_DEBUGGER(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER)
-+#define DUK_HEAP_STRING_DEFAULT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT)
-+#define DUK_HTHREAD_STRING_DEFAULT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT)
-+#define DUK_HEAP_STRING_DELETE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE)
-+#define DUK_HTHREAD_STRING_DELETE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE)
-+#define DUK_HEAP_STRING_DO(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO)
-+#define DUK_HTHREAD_STRING_DO(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO)
-+#define DUK_HEAP_STRING_ELSE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE)
-+#define DUK_HTHREAD_STRING_ELSE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE)
-+#define DUK_HEAP_STRING_FINALLY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY)
-+#define DUK_HTHREAD_STRING_FINALLY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY)
-+#define DUK_HEAP_STRING_FOR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR)
-+#define DUK_HTHREAD_STRING_FOR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR)
-+#define DUK_HEAP_STRING_LC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION)
-+#define DUK_HTHREAD_STRING_LC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION)
-+#define DUK_HEAP_STRING_IF(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF)
-+#define DUK_HTHREAD_STRING_IF(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF)
-+#define DUK_HEAP_STRING_IN(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN)
-+#define DUK_HTHREAD_STRING_IN(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN)
-+#define DUK_HEAP_STRING_INSTANCEOF(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF)
-+#define DUK_HTHREAD_STRING_INSTANCEOF(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF)
-+#define DUK_HEAP_STRING_NEW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW)
-+#define DUK_HTHREAD_STRING_NEW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW)
-+#define DUK_HEAP_STRING_RETURN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN)
-+#define DUK_HTHREAD_STRING_RETURN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN)
-+#define DUK_HEAP_STRING_SWITCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH)
-+#define DUK_HTHREAD_STRING_SWITCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH)
-+#define DUK_HEAP_STRING_THIS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS)
-+#define DUK_HTHREAD_STRING_THIS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS)
-+#define DUK_HEAP_STRING_THROW(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW)
-+#define DUK_HTHREAD_STRING_THROW(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW)
-+#define DUK_HEAP_STRING_TRY(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY)
-+#define DUK_HTHREAD_STRING_TRY(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY)
-+#define DUK_HEAP_STRING_TYPEOF(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF)
-+#define DUK_HTHREAD_STRING_TYPEOF(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF)
-+#define DUK_HEAP_STRING_VAR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR)
-+#define DUK_HTHREAD_STRING_VAR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR)
-+#define DUK_HEAP_STRING_VOID(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID)
-+#define DUK_HTHREAD_STRING_VOID(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID)
-+#define DUK_HEAP_STRING_WHILE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE)
-+#define DUK_HTHREAD_STRING_WHILE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE)
-+#define DUK_HEAP_STRING_WITH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH)
-+#define DUK_HTHREAD_STRING_WITH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH)
-+#define DUK_HEAP_STRING_CLASS(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS)
-+#define DUK_HTHREAD_STRING_CLASS(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS)
-+#define DUK_HEAP_STRING_CONST(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST)
-+#define DUK_HTHREAD_STRING_CONST(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST)
-+#define DUK_HEAP_STRING_ENUM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM)
-+#define DUK_HTHREAD_STRING_ENUM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM)
-+#define DUK_HEAP_STRING_EXPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT)
-+#define DUK_HTHREAD_STRING_EXPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT)
-+#define DUK_HEAP_STRING_EXTENDS(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS)
-+#define DUK_HTHREAD_STRING_EXTENDS(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS)
-+#define DUK_HEAP_STRING_IMPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT)
-+#define DUK_HTHREAD_STRING_IMPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT)
-+#define DUK_HEAP_STRING_SUPER(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER)
-+#define DUK_HTHREAD_STRING_SUPER(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER)
-+#define DUK_HEAP_STRING_LC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL)
-+#define DUK_HTHREAD_STRING_LC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL)
-+#define DUK_HEAP_STRING_TRUE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE)
-+#define DUK_HTHREAD_STRING_TRUE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE)
-+#define DUK_HEAP_STRING_FALSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE)
-+#define DUK_HTHREAD_STRING_FALSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE)
-+#define DUK_HEAP_STRING_IMPLEMENTS(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS)
-+#define DUK_HTHREAD_STRING_IMPLEMENTS(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS)
-+#define DUK_HEAP_STRING_INTERFACE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE)
-+#define DUK_HTHREAD_STRING_INTERFACE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE)
-+#define DUK_HEAP_STRING_LET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET)
-+#define DUK_HTHREAD_STRING_LET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET)
-+#define DUK_HEAP_STRING_PACKAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE)
-+#define DUK_HTHREAD_STRING_PACKAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE)
-+#define DUK_HEAP_STRING_PRIVATE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE)
-+#define DUK_HTHREAD_STRING_PRIVATE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE)
-+#define DUK_HEAP_STRING_PROTECTED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED)
-+#define DUK_HTHREAD_STRING_PROTECTED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED)
-+#define DUK_HEAP_STRING_PUBLIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC)
-+#define DUK_HTHREAD_STRING_PUBLIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC)
-+#define DUK_HEAP_STRING_STATIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC)
-+#define DUK_HTHREAD_STRING_STATIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC)
-+#define DUK_HEAP_STRING_YIELD(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD)
-+#define DUK_HTHREAD_STRING_YIELD(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD)
-+
-+#define DUK_HEAP_NUM_STRINGS                                          336
-+
-+#define DUK_STRIDX_START_RESERVED                                     291
-+#define DUK_STRIDX_START_STRICT_RESERVED                              327
-+#define DUK_STRIDX_END_RESERVED                                       336                            /* exclusive endpoint */
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128];
-+DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341];
-+#ifdef DUK_USE_BUILTIN_INITJS
-+DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187];
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_BUILTINS_DATA_LENGTH                                      1341
-+#ifdef DUK_USE_BUILTIN_INITJS
-+#define DUK_BUILTIN_INITJS_DATA_LENGTH                                187
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+
-+#define DUK_BIDX_GLOBAL                                               0
-+#define DUK_BIDX_GLOBAL_ENV                                           1
-+#define DUK_BIDX_OBJECT_CONSTRUCTOR                                   2
-+#define DUK_BIDX_OBJECT_PROTOTYPE                                     3
-+#define DUK_BIDX_FUNCTION_CONSTRUCTOR                                 4
-+#define DUK_BIDX_FUNCTION_PROTOTYPE                                   5
-+#define DUK_BIDX_ARRAY_CONSTRUCTOR                                    6
-+#define DUK_BIDX_ARRAY_PROTOTYPE                                      7
-+#define DUK_BIDX_STRING_CONSTRUCTOR                                   8
-+#define DUK_BIDX_STRING_PROTOTYPE                                     9
-+#define DUK_BIDX_BOOLEAN_CONSTRUCTOR                                  10
-+#define DUK_BIDX_BOOLEAN_PROTOTYPE                                    11
-+#define DUK_BIDX_NUMBER_CONSTRUCTOR                                   12
-+#define DUK_BIDX_NUMBER_PROTOTYPE                                     13
-+#define DUK_BIDX_DATE_CONSTRUCTOR                                     14
-+#define DUK_BIDX_DATE_PROTOTYPE                                       15
-+#define DUK_BIDX_REGEXP_CONSTRUCTOR                                   16
-+#define DUK_BIDX_REGEXP_PROTOTYPE                                     17
-+#define DUK_BIDX_ERROR_CONSTRUCTOR                                    18
-+#define DUK_BIDX_ERROR_PROTOTYPE                                      19
-+#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR                               20
-+#define DUK_BIDX_EVAL_ERROR_PROTOTYPE                                 21
-+#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR                              22
-+#define DUK_BIDX_RANGE_ERROR_PROTOTYPE                                23
-+#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR                          24
-+#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE                            25
-+#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR                             26
-+#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE                               27
-+#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR                               28
-+#define DUK_BIDX_TYPE_ERROR_PROTOTYPE                                 29
-+#define DUK_BIDX_URI_ERROR_CONSTRUCTOR                                30
-+#define DUK_BIDX_URI_ERROR_PROTOTYPE                                  31
-+#define DUK_BIDX_MATH                                                 32
-+#define DUK_BIDX_JSON                                                 33
-+#define DUK_BIDX_TYPE_ERROR_THROWER                                   34
-+#define DUK_BIDX_PROXY_CONSTRUCTOR                                    35
-+#define DUK_BIDX_DUKTAPE                                              36
-+#define DUK_BIDX_THREAD_CONSTRUCTOR                                   37
-+#define DUK_BIDX_THREAD_PROTOTYPE                                     38
-+#define DUK_BIDX_BUFFER_CONSTRUCTOR                                   39
-+#define DUK_BIDX_BUFFER_PROTOTYPE                                     40
-+#define DUK_BIDX_POINTER_CONSTRUCTOR                                  41
-+#define DUK_BIDX_POINTER_PROTOTYPE                                    42
-+#define DUK_BIDX_LOGGER_CONSTRUCTOR                                   43
-+#define DUK_BIDX_LOGGER_PROTOTYPE                                     44
-+#define DUK_BIDX_DOUBLE_ERROR                                         45
-+
-+#define DUK_NUM_BUILTINS                                              46
-+
-+#else
-+#error invalid endianness defines
-+#endif
-+#endif  /* DUK_BUILTINS_H_INCLUDED */
-+#line 50 "duk_internal.h"
-+
-+#line 1 "duk_strings.h"
-+/*
-+ *  Shared error messages: declarations and macros
-+ *
-+ *  Error messages are accessed through macros with fine-grained, explicit
-+ *  error message distinctions.  Concrete error messages are selected by the
-+ *  macros and multiple macros can map to the same concrete string to save
-+ *  on code footprint.  This allows flexible footprint/verbosity tuning with
-+ *  minimal code impact.  There are a few limitations to this approach:
-+ *  (1) switching between plain messages and format strings doesn't work
-+ *  conveniently, and (2) conditional strings are a bit awkward to handle.
-+ *
-+ *  Because format strings behave differently in the call site (they need to
-+ *  be followed by format arguments), they have a special prefix (DUK_STR_FMT_
-+ *  and duk_str_fmt_).
-+ *
-+ *  On some compilers using explicit shared strings is preferable; on others
-+ *  it may be better to use straight literals because the compiler will combine
-+ *  them anyway, and such strings won't end up unnecessarily in a symbol table.
-+ */
-+
-+#ifndef DUK_ERRMSG_H_INCLUDED
-+#define DUK_ERRMSG_H_INCLUDED
-+
-+#define DUK_STR_INTERNAL_ERROR duk_str_internal_error
-+#define DUK_STR_INVALID_COUNT duk_str_invalid_count
-+#define DUK_STR_INVALID_CALL_ARGS duk_str_invalid_call_args
-+#define DUK_STR_NOT_CONSTRUCTABLE duk_str_not_constructable
-+#define DUK_STR_NOT_CALLABLE duk_str_not_callable
-+#define DUK_STR_NOT_EXTENSIBLE duk_str_not_extensible
-+#define DUK_STR_NOT_WRITABLE duk_str_not_writable
-+#define DUK_STR_NOT_CONFIGURABLE duk_str_not_configurable
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_internal_error;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_count;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_call_args;
-+DUK_INTERNAL_DECL const char *duk_str_not_constructable;
-+DUK_INTERNAL_DECL const char *duk_str_not_callable;
-+DUK_INTERNAL_DECL const char *duk_str_not_extensible;
-+DUK_INTERNAL_DECL const char *duk_str_not_writable;
-+DUK_INTERNAL_DECL const char *duk_str_not_configurable;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STR_INVALID_CONTEXT duk_str_invalid_context
-+#define DUK_STR_INVALID_INDEX duk_str_invalid_index
-+#define DUK_STR_PUSH_BEYOND_ALLOC_STACK duk_str_push_beyond_alloc_stack
-+#define DUK_STR_NOT_UNDEFINED duk_str_not_undefined
-+#define DUK_STR_NOT_NULL duk_str_not_null
-+#define DUK_STR_NOT_BOOLEAN duk_str_not_boolean
-+#define DUK_STR_NOT_NUMBER duk_str_not_number
-+#define DUK_STR_NOT_STRING duk_str_not_string
-+#define DUK_STR_NOT_POINTER duk_str_not_pointer
-+#define DUK_STR_NOT_BUFFER duk_str_not_buffer
-+#define DUK_STR_UNEXPECTED_TYPE duk_str_unexpected_type
-+#define DUK_STR_NOT_THREAD duk_str_not_thread
-+#if 0  /*unused*/
-+#define DUK_STR_NOT_COMPILEDFUNCTION duk_str_not_compiledfunction
-+#endif
-+#define DUK_STR_NOT_NATIVEFUNCTION duk_str_not_nativefunction
-+#define DUK_STR_NOT_C_FUNCTION duk_str_not_c_function
-+#define DUK_STR_DEFAULTVALUE_COERCE_FAILED duk_str_defaultvalue_coerce_failed
-+#define DUK_STR_NUMBER_OUTSIDE_RANGE duk_str_number_outside_range
-+#define DUK_STR_NOT_OBJECT_COERCIBLE duk_str_not_object_coercible
-+#define DUK_STR_STRING_TOO_LONG duk_str_string_too_long
-+#define DUK_STR_BUFFER_TOO_LONG duk_str_buffer_too_long
-+#define DUK_STR_SPRINTF_TOO_LONG duk_str_sprintf_too_long
-+#define DUK_STR_OBJECT_ALLOC_FAILED duk_str_object_alloc_failed
-+#define DUK_STR_THREAD_ALLOC_FAILED duk_str_thread_alloc_failed
-+#define DUK_STR_FUNC_ALLOC_FAILED duk_str_func_alloc_failed
-+#define DUK_STR_BUFFER_ALLOC_FAILED duk_str_buffer_alloc_failed
-+#define DUK_STR_POP_TOO_MANY duk_str_pop_too_many
-+#define DUK_STR_BUFFER_NOT_DYNAMIC duk_str_buffer_not_dynamic
-+#define DUK_STR_FAILED_TO_EXTEND_VALSTACK duk_str_failed_to_extend_valstack
-+#define DUK_STR_BASE64_ENCODE_FAILED duk_str_base64_encode_failed
-+#define DUK_STR_BASE64_DECODE_FAILED duk_str_base64_decode_failed
-+#define DUK_STR_HEX_DECODE_FAILED duk_str_hex_decode_failed
-+#define DUK_STR_NO_SOURCECODE duk_str_no_sourcecode
-+#define DUK_STR_CONCAT_RESULT_TOO_LONG duk_str_concat_result_too_long
-+#define DUK_STR_UNIMPLEMENTED duk_str_unimplemented
-+#define DUK_STR_ARRAY_LENGTH_OVER_2G duk_str_array_length_over_2g
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_invalid_context;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_index;
-+DUK_INTERNAL_DECL const char *duk_str_push_beyond_alloc_stack;
-+DUK_INTERNAL_DECL const char *duk_str_not_undefined;
-+DUK_INTERNAL_DECL const char *duk_str_not_null;
-+DUK_INTERNAL_DECL const char *duk_str_not_boolean;
-+DUK_INTERNAL_DECL const char *duk_str_not_number;
-+DUK_INTERNAL_DECL const char *duk_str_not_string;
-+DUK_INTERNAL_DECL const char *duk_str_not_pointer;
-+DUK_INTERNAL_DECL const char *duk_str_not_buffer;
-+DUK_INTERNAL_DECL const char *duk_str_unexpected_type;
-+DUK_INTERNAL_DECL const char *duk_str_not_thread;
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL const char *duk_str_not_compiledfunction;
-+#endif
-+DUK_INTERNAL_DECL const char *duk_str_not_nativefunction;
-+DUK_INTERNAL_DECL const char *duk_str_not_c_function;
-+DUK_INTERNAL_DECL const char *duk_str_defaultvalue_coerce_failed;
-+DUK_INTERNAL_DECL const char *duk_str_number_outside_range;
-+DUK_INTERNAL_DECL const char *duk_str_not_object_coercible;
-+DUK_INTERNAL_DECL const char *duk_str_string_too_long;
-+DUK_INTERNAL_DECL const char *duk_str_buffer_too_long;
-+DUK_INTERNAL_DECL const char *duk_str_sprintf_too_long;
-+DUK_INTERNAL_DECL const char *duk_str_object_alloc_failed;
-+DUK_INTERNAL_DECL const char *duk_str_thread_alloc_failed;
-+DUK_INTERNAL_DECL const char *duk_str_func_alloc_failed;
-+DUK_INTERNAL_DECL const char *duk_str_buffer_alloc_failed;
-+DUK_INTERNAL_DECL const char *duk_str_pop_too_many;
-+DUK_INTERNAL_DECL const char *duk_str_buffer_not_dynamic;
-+DUK_INTERNAL_DECL const char *duk_str_failed_to_extend_valstack;
-+DUK_INTERNAL_DECL const char *duk_str_base64_encode_failed;
-+DUK_INTERNAL_DECL const char *duk_str_base64_decode_failed;
-+DUK_INTERNAL_DECL const char *duk_str_hex_decode_failed;
-+DUK_INTERNAL_DECL const char *duk_str_no_sourcecode;
-+DUK_INTERNAL_DECL const char *duk_str_concat_result_too_long;
-+DUK_INTERNAL_DECL const char *duk_str_unimplemented;
-+DUK_INTERNAL_DECL const char *duk_str_array_length_over_2g;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STR_FMT_PTR duk_str_fmt_ptr
-+#define DUK_STR_FMT_INVALID_JSON duk_str_fmt_invalid_json
-+#define DUK_STR_JSONDEC_RECLIMIT duk_str_jsondec_reclimit
-+#define DUK_STR_JSONENC_RECLIMIT duk_str_jsonenc_reclimit
-+#define DUK_STR_CYCLIC_INPUT duk_str_cyclic_input
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_fmt_ptr;
-+DUK_INTERNAL_DECL const char *duk_str_fmt_invalid_json;
-+DUK_INTERNAL_DECL const char *duk_str_jsondec_reclimit;
-+DUK_INTERNAL_DECL const char *duk_str_jsonenc_reclimit;
-+DUK_INTERNAL_DECL const char *duk_str_cyclic_input;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STR_PROXY_REVOKED duk_str_proxy_revoked
-+#define DUK_STR_OBJECT_RESIZE_FAILED duk_str_object_resize_failed
-+#define DUK_STR_INVALID_BASE duk_str_invalid_base
-+#define DUK_STR_STRICT_CALLER_READ duk_str_strict_caller_read
-+#define DUK_STR_PROXY_REJECTED duk_str_proxy_rejected
-+#define DUK_STR_INVALID_ARRAY_LENGTH duk_str_invalid_array_length
-+#define DUK_STR_ARRAY_LENGTH_WRITE_FAILED duk_str_array_length_write_failed
-+#define DUK_STR_ARRAY_LENGTH_NOT_WRITABLE duk_str_array_length_not_writable
-+#define DUK_STR_SETTER_UNDEFINED duk_str_setter_undefined
-+#define DUK_STR_REDEFINE_VIRT_PROP duk_str_redefine_virt_prop
-+#define DUK_STR_INVALID_DESCRIPTOR duk_str_invalid_descriptor
-+#define DUK_STR_PROPERTY_IS_VIRTUAL duk_str_property_is_virtual
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_proxy_revoked;
-+DUK_INTERNAL_DECL const char *duk_str_object_resize_failed;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_base;
-+DUK_INTERNAL_DECL const char *duk_str_strict_caller_read;
-+DUK_INTERNAL_DECL const char *duk_str_proxy_rejected;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_array_length;
-+DUK_INTERNAL_DECL const char *duk_str_array_length_write_failed;
-+DUK_INTERNAL_DECL const char *duk_str_array_length_not_writable;
-+DUK_INTERNAL_DECL const char *duk_str_setter_undefined;
-+DUK_INTERNAL_DECL const char *duk_str_redefine_virt_prop;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_descriptor;
-+DUK_INTERNAL_DECL const char *duk_str_property_is_virtual;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STR_PARSE_ERROR duk_str_parse_error
-+#define DUK_STR_DUPLICATE_LABEL duk_str_duplicate_label
-+#define DUK_STR_INVALID_LABEL duk_str_invalid_label
-+#define DUK_STR_INVALID_ARRAY_LITERAL duk_str_invalid_array_literal
-+#define DUK_STR_INVALID_OBJECT_LITERAL duk_str_invalid_object_literal
-+#define DUK_STR_INVALID_VAR_DECLARATION duk_str_invalid_var_declaration
-+#define DUK_STR_CANNOT_DELETE_IDENTIFIER duk_str_cannot_delete_identifier
-+#define DUK_STR_INVALID_EXPRESSION duk_str_invalid_expression
-+#define DUK_STR_INVALID_LVALUE duk_str_invalid_lvalue
-+#define DUK_STR_EXPECTED_IDENTIFIER duk_str_expected_identifier
-+#define DUK_STR_EMPTY_EXPR_NOT_ALLOWED duk_str_empty_expr_not_allowed
-+#define DUK_STR_INVALID_FOR duk_str_invalid_for
-+#define DUK_STR_INVALID_SWITCH duk_str_invalid_switch
-+#define DUK_STR_INVALID_BREAK_CONT_LABEL duk_str_invalid_break_cont_label
-+#define DUK_STR_INVALID_RETURN duk_str_invalid_return
-+#define DUK_STR_INVALID_TRY duk_str_invalid_try
-+#define DUK_STR_INVALID_THROW duk_str_invalid_throw
-+#define DUK_STR_WITH_IN_STRICT_MODE duk_str_with_in_strict_mode
-+#define DUK_STR_FUNC_STMT_NOT_ALLOWED duk_str_func_stmt_not_allowed
-+#define DUK_STR_UNTERMINATED_STMT duk_str_unterminated_stmt
-+#define DUK_STR_INVALID_ARG_NAME duk_str_invalid_arg_name
-+#define DUK_STR_INVALID_FUNC_NAME duk_str_invalid_func_name
-+#define DUK_STR_INVALID_GETSET_NAME duk_str_invalid_getset_name
-+#define DUK_STR_FUNC_NAME_REQUIRED duk_str_func_name_required
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_parse_error;
-+DUK_INTERNAL_DECL const char *duk_str_duplicate_label;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_label;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_array_literal;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_object_literal;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_var_declaration;
-+DUK_INTERNAL_DECL const char *duk_str_cannot_delete_identifier;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_expression;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_lvalue;
-+DUK_INTERNAL_DECL const char *duk_str_expected_identifier;
-+DUK_INTERNAL_DECL const char *duk_str_empty_expr_not_allowed;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_for;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_switch;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_break_cont_label;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_return;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_try;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_throw;
-+DUK_INTERNAL_DECL const char *duk_str_with_in_strict_mode;
-+DUK_INTERNAL_DECL const char *duk_str_func_stmt_not_allowed;
-+DUK_INTERNAL_DECL const char *duk_str_unterminated_stmt;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_arg_name;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_func_name;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_getset_name;
-+DUK_INTERNAL_DECL const char *duk_str_func_name_required;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STR_INTERNAL_ERROR_EXEC_LONGJMP duk_str_internal_error_exec_longjmp
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_internal_error_exec_longjmp;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STR_INVALID_QUANTIFIER_NO_ATOM duk_str_invalid_quantifier_no_atom
-+#define DUK_STR_INVALID_QUANTIFIER_VALUES duk_str_invalid_quantifier_values
-+#define DUK_STR_QUANTIFIER_TOO_MANY_COPIES duk_str_quantifier_too_many_copies
-+#define DUK_STR_UNEXPECTED_CLOSING_PAREN duk_str_unexpected_closing_paren
-+#define DUK_STR_UNEXPECTED_END_OF_PATTERN duk_str_unexpected_end_of_pattern
-+#define DUK_STR_UNEXPECTED_REGEXP_TOKEN duk_str_unexpected_regexp_token
-+#define DUK_STR_INVALID_REGEXP_FLAGS duk_str_invalid_regexp_flags
-+#define DUK_STR_INVALID_BACKREFS duk_str_invalid_backrefs
-+#define DUK_STR_REGEXP_BACKTRACK_FAILED duk_str_regexp_backtrack_failed
-+#define DUK_STR_REGEXP_ADVANCE_FAILED duk_str_regexp_advance_failed
-+#define DUK_STR_REGEXP_INTERNAL_ERROR duk_str_regexp_internal_error
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_invalid_quantifier_no_atom;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_quantifier_values;
-+DUK_INTERNAL_DECL const char *duk_str_quantifier_too_many_copies;
-+DUK_INTERNAL_DECL const char *duk_str_unexpected_closing_paren;
-+DUK_INTERNAL_DECL const char *duk_str_unexpected_end_of_pattern;
-+DUK_INTERNAL_DECL const char *duk_str_unexpected_regexp_token;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_regexp_flags;
-+DUK_INTERNAL_DECL const char *duk_str_invalid_backrefs;
-+DUK_INTERNAL_DECL const char *duk_str_regexp_backtrack_failed;
-+DUK_INTERNAL_DECL const char *duk_str_regexp_advance_failed;
-+DUK_INTERNAL_DECL const char *duk_str_regexp_internal_error;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STR_VALSTACK_LIMIT duk_str_valstack_limit
-+#define DUK_STR_CALLSTACK_LIMIT duk_str_callstack_limit
-+#define DUK_STR_CATCHSTACK_LIMIT duk_str_catchstack_limit
-+#define DUK_STR_OBJECT_PROPERTY_LIMIT duk_str_object_property_limit
-+#define DUK_STR_PROTOTYPE_CHAIN_LIMIT duk_str_prototype_chain_limit
-+#define DUK_STR_BOUND_CHAIN_LIMIT duk_str_bound_chain_limit
-+#define DUK_STR_C_CALLSTACK_LIMIT duk_str_c_callstack_limit
-+#define DUK_STR_COMPILER_RECURSION_LIMIT duk_str_compiler_recursion_limit
-+#define DUK_STR_BYTECODE_LIMIT duk_str_bytecode_limit
-+#define DUK_STR_REG_LIMIT duk_str_reg_limit
-+#define DUK_STR_TEMP_LIMIT duk_str_temp_limit
-+#define DUK_STR_CONST_LIMIT duk_str_const_limit
-+#define DUK_STR_FUNC_LIMIT duk_str_func_limit
-+#define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT duk_str_regexp_compiler_recursion_limit
-+#define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT duk_str_regexp_executor_recursion_limit
-+#define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT duk_str_regexp_executor_step_limit
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_valstack_limit;
-+DUK_INTERNAL_DECL const char *duk_str_callstack_limit;
-+DUK_INTERNAL_DECL const char *duk_str_catchstack_limit;
-+DUK_INTERNAL_DECL const char *duk_str_object_property_limit;
-+DUK_INTERNAL_DECL const char *duk_str_prototype_chain_limit;
-+DUK_INTERNAL_DECL const char *duk_str_bound_chain_limit;
-+DUK_INTERNAL_DECL const char *duk_str_c_callstack_limit;
-+DUK_INTERNAL_DECL const char *duk_str_compiler_recursion_limit;
-+DUK_INTERNAL_DECL const char *duk_str_bytecode_limit;
-+DUK_INTERNAL_DECL const char *duk_str_reg_limit;
-+DUK_INTERNAL_DECL const char *duk_str_temp_limit;
-+DUK_INTERNAL_DECL const char *duk_str_const_limit;
-+DUK_INTERNAL_DECL const char *duk_str_func_limit;
-+DUK_INTERNAL_DECL const char *duk_str_regexp_compiler_recursion_limit;
-+DUK_INTERNAL_DECL const char *duk_str_regexp_executor_recursion_limit;
-+DUK_INTERNAL_DECL const char *duk_str_regexp_executor_step_limit;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#define DUK_STR_ANON duk_str_anon
-+#define DUK_STR_REALLOC_FAILED duk_str_realloc_failed
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_str_anon;
-+DUK_INTERNAL_DECL const char *duk_str_realloc_failed;
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+#endif  /* DUK_ERRMSG_H_INCLUDED */
-+#line 1 "duk_js_bytecode.h"
-+/*
-+ *  Ecmascript bytecode
-+ */
-+
-+#ifndef DUK_JS_BYTECODE_H_INCLUDED
-+#define DUK_JS_BYTECODE_H_INCLUDED
-+
-+/*
-+ *  Logical instruction layout
-+ *  ==========================
-+ *
-+ *  !3!3!2!2!2!2!2!2!2!2!2!2!1!1!1!1!1!1!1!1!1!1! ! ! ! ! ! ! ! ! ! !
-+ *  !1!0!9!8!7!6!5!4!3!2!1!0!9!8!7!6!5!4!3!2!1!0!9!8!7!6!5!4!3!2!1!0!
-+ *  +---------------------------------------------------+-----------+
-+ *  !       C         !       B         !      A        !    OP     !
-+ *  +---------------------------------------------------+-----------+
-+ *
-+ *  OP (6 bits):  opcode (DUK_OP_*), access should be fastest
-+ *  A (8 bits):   typically a target register number
-+ *  B (9 bits):   typically first source register/constant number
-+ *  C (9 bits):   typically second source register/constant number
-+ *
-+ *  Some instructions combine BC or ABC together for larger parameter values.
-+ *  Signed integers (e.g. jump offsets) are encoded as unsigned, with an opcode
-+ *  specific bias.  B and C may denote a register or a constant, see
-+ *  DUK_BC_ISREG() and DUK_BC_ISCONST().
-+ *
-+ *  Note: macro naming is a bit misleading, e.g. "ABC" in macro name but
-+ *  the field layout is logically "CBA".
-+ */
-+
-+typedef duk_uint32_t duk_instr_t;
-+
-+#define DUK_DEC_OP(x)               ((x) & 0x3fUL)
-+#define DUK_DEC_A(x)                (((x) >> 6) & 0xffUL)
-+#define DUK_DEC_B(x)                (((x) >> 14) & 0x1ffUL)
-+#define DUK_DEC_C(x)                (((x) >> 23) & 0x1ffUL)
-+#define DUK_DEC_BC(x)               (((x) >> 14) & 0x3ffffUL)
-+#define DUK_DEC_ABC(x)              (((x) >> 6) & 0x3ffffffUL)
-+
-+#define DUK_ENC_OP(op)              ((duk_instr_t) (op))
-+#define DUK_ENC_OP_ABC(op,abc)      ((duk_instr_t) ( \
-+                                        (((duk_instr_t) (abc)) << 6) | \
-+                                        ((duk_instr_t) (op)) \
-+                                    ))
-+#define DUK_ENC_OP_A_BC(op,a,bc)    ((duk_instr_t) ( \
-+                                        (((duk_instr_t) (bc)) << 14) | \
-+                                        (((duk_instr_t) (a)) << 6) | \
-+                                        ((duk_instr_t) (op)) \
-+                                    ))
-+#define DUK_ENC_OP_A_B_C(op,a,b,c)  ((duk_instr_t) ( \
-+                                        (((duk_instr_t) (c)) << 23) | \
-+                                        (((duk_instr_t) (b)) << 14) | \
-+                                        (((duk_instr_t) (a)) << 6) | \
-+                                        ((duk_instr_t) (op)) \
-+                                    ))
-+#define DUK_ENC_OP_A_B(op,a,b)      DUK_ENC_OP_A_B_C(op,a,b,0)
-+#define DUK_ENC_OP_A(op,a)          DUK_ENC_OP_A_B_C(op,a,0,0)
-+
-+/* Constants should be signed so that signed arithmetic involving them
-+ * won't cause values to be coerced accidentally to unsigned.
-+ */
-+#define DUK_BC_OP_MIN               0
-+#define DUK_BC_OP_MAX               0x3fL
-+#define DUK_BC_A_MIN                0
-+#define DUK_BC_A_MAX                0xffL
-+#define DUK_BC_B_MIN                0
-+#define DUK_BC_B_MAX                0x1ffL
-+#define DUK_BC_C_MIN                0
-+#define DUK_BC_C_MAX                0x1ffL
-+#define DUK_BC_BC_MIN               0
-+#define DUK_BC_BC_MAX               0x3ffffL
-+#define DUK_BC_ABC_MIN              0
-+#define DUK_BC_ABC_MAX              0x3ffffffL
-+#define DUK_BC_EXTRAOP_MIN          DUK_BC_A_MIN
-+#define DUK_BC_EXTRAOP_MAX          DUK_BC_A_MAX
-+
-+#define DUK_OP_LDREG                0
-+#define DUK_OP_STREG                1
-+#define DUK_OP_LDCONST              2
-+#define DUK_OP_LDINT                3
-+#define DUK_OP_LDINTX               4
-+#define DUK_OP_MPUTOBJ              5
-+#define DUK_OP_MPUTOBJI             6
-+#define DUK_OP_MPUTARR              7
-+#define DUK_OP_MPUTARRI             8
-+#define DUK_OP_NEW                  9
-+#define DUK_OP_NEWI                 10
-+#define DUK_OP_REGEXP               11
-+#define DUK_OP_CSREG                12
-+#define DUK_OP_CSREGI               13
-+#define DUK_OP_GETVAR               14
-+#define DUK_OP_PUTVAR               15
-+#define DUK_OP_DECLVAR              16
-+#define DUK_OP_DELVAR               17
-+#define DUK_OP_CSVAR                18
-+#define DUK_OP_CSVARI               19
-+#define DUK_OP_CLOSURE              20
-+#define DUK_OP_GETPROP              21
-+#define DUK_OP_PUTPROP              22
-+#define DUK_OP_DELPROP              23
-+#define DUK_OP_CSPROP               24
-+#define DUK_OP_CSPROPI              25
-+#define DUK_OP_ADD                  26
-+#define DUK_OP_SUB                  27
-+#define DUK_OP_MUL                  28
-+#define DUK_OP_DIV                  29
-+#define DUK_OP_MOD                  30
-+#define DUK_OP_BAND                 31
-+#define DUK_OP_BOR                  32
-+#define DUK_OP_BXOR                 33
-+#define DUK_OP_BASL                 34
-+#define DUK_OP_BLSR                 35
-+#define DUK_OP_BASR                 36
-+#define DUK_OP_EQ                   37
-+#define DUK_OP_NEQ                  38
-+#define DUK_OP_SEQ                  39
-+#define DUK_OP_SNEQ                 40
-+#define DUK_OP_GT                   41
-+#define DUK_OP_GE                   42
-+#define DUK_OP_LT                   43
-+#define DUK_OP_LE                   44
-+#define DUK_OP_IF                   45
-+#define DUK_OP_JUMP                 46
-+#define DUK_OP_RETURN               47
-+#define DUK_OP_CALL                 48
-+#define DUK_OP_CALLI                49
-+#define DUK_OP_TRYCATCH             50
-+#define DUK_OP_EXTRA                51
-+#define DUK_OP_PREINCR              52  /* pre/post opcode values have constraints, */
-+#define DUK_OP_PREDECR              53  /* see duk_js_executor.c */
-+#define DUK_OP_POSTINCR             54
-+#define DUK_OP_POSTDECR             55
-+#define DUK_OP_PREINCV              56
-+#define DUK_OP_PREDECV              57
-+#define DUK_OP_POSTINCV             58
-+#define DUK_OP_POSTDECV             59
-+#define DUK_OP_PREINCP              60
-+#define DUK_OP_PREDECP              61
-+#define DUK_OP_POSTINCP             62
-+#define DUK_OP_POSTDECP             63
-+#define DUK_OP_NONE                 64  /* dummy value used as marker */
-+
-+/* DUK_OP_EXTRA, sub-operation in A */
-+#define DUK_EXTRAOP_NOP             0
-+#define DUK_EXTRAOP_INVALID         1
-+#define DUK_EXTRAOP_LDTHIS          2
-+#define DUK_EXTRAOP_LDUNDEF         3
-+#define DUK_EXTRAOP_LDNULL          4
-+#define DUK_EXTRAOP_LDTRUE          5
-+#define DUK_EXTRAOP_LDFALSE         6
-+#define DUK_EXTRAOP_NEWOBJ          7
-+#define DUK_EXTRAOP_NEWARR          8
-+#define DUK_EXTRAOP_SETALEN         9
-+#define DUK_EXTRAOP_TYPEOF          10
-+#define DUK_EXTRAOP_TYPEOFID        11
-+#define DUK_EXTRAOP_INITENUM        12
-+#define DUK_EXTRAOP_NEXTENUM        13
-+#define DUK_EXTRAOP_INITSET         14
-+#define DUK_EXTRAOP_INITSETI        15
-+#define DUK_EXTRAOP_INITGET         16
-+#define DUK_EXTRAOP_INITGETI        17
-+#define DUK_EXTRAOP_ENDTRY          18
-+#define DUK_EXTRAOP_ENDCATCH        19
-+#define DUK_EXTRAOP_ENDFIN          20
-+#define DUK_EXTRAOP_THROW           21
-+#define DUK_EXTRAOP_INVLHS          22
-+#define DUK_EXTRAOP_UNM             23
-+#define DUK_EXTRAOP_UNP             24
-+#define DUK_EXTRAOP_DEBUGGER        25
-+#define DUK_EXTRAOP_BREAK           26
-+#define DUK_EXTRAOP_CONTINUE        27
-+#define DUK_EXTRAOP_BNOT            28
-+#define DUK_EXTRAOP_LNOT            29
-+#define DUK_EXTRAOP_INSTOF          30
-+#define DUK_EXTRAOP_IN              31
-+#define DUK_EXTRAOP_LABEL           32
-+#define DUK_EXTRAOP_ENDLABEL        33
-+
-+/* DUK_OP_EXTRA for debugging */
-+#define DUK_EXTRAOP_DUMPREG         128
-+#define DUK_EXTRAOP_DUMPREGS        129
-+#define DUK_EXTRAOP_LOGMARK         130
-+
-+/* DUK_OP_CALL flags in A */
-+#define DUK_BC_CALL_FLAG_TAILCALL           (1 << 0)
-+#define DUK_BC_CALL_FLAG_EVALCALL           (1 << 1)
-+
-+/* DUK_OP_TRYCATCH flags in A */
-+#define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH     (1 << 0)
-+#define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY   (1 << 1)
-+#define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING  (1 << 2)
-+#define DUK_BC_TRYCATCH_FLAG_WITH_BINDING   (1 << 3)
-+
-+/* DUK_OP_RETURN flags in A */
-+#define DUK_BC_RETURN_FLAG_FAST             (1 << 0)
-+#define DUK_BC_RETURN_FLAG_HAVE_RETVAL      (1 << 1)
-+
-+/* DUK_OP_DECLVAR flags in A; bottom bits are reserved for propdesc flags (DUK_PROPDESC_FLAG_XXX) */
-+#define DUK_BC_DECLVAR_FLAG_UNDEF_VALUE     (1 << 4)  /* use 'undefined' for value automatically */
-+#define DUK_BC_DECLVAR_FLAG_FUNC_DECL       (1 << 5)  /* function declaration */
-+
-+/* misc constants and helper macros */
-+#define DUK_BC_REGLIMIT             256  /* if B/C is >= this value, refers to a const */
-+#define DUK_BC_ISREG(x)             ((x) < DUK_BC_REGLIMIT)
-+#define DUK_BC_ISCONST(x)           ((x) >= DUK_BC_REGLIMIT)
-+#define DUK_BC_LDINT_BIAS           (1L << 17)
-+#define DUK_BC_LDINTX_SHIFT         18
-+#define DUK_BC_JUMP_BIAS            (1L << 25)
-+
-+#endif  /* DUK_JS_BYTECODE_H_INCLUDED */
-+#line 1 "duk_lexer.h"
-+/*
-+ *  Lexer defines.
-+ */
-+
-+#ifndef DUK_LEXER_H_INCLUDED
-+#define DUK_LEXER_H_INCLUDED
-+
-+typedef void (*duk_re_range_callback)(void *user, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct);
-+
-+/*
-+ *  A token is interpreted as any possible production of InputElementDiv
-+ *  and InputElementRegExp, see E5 Section 7 in its entirety.  Note that
-+ *  the E5 "Token" production does not cover all actual tokens of the
-+ *  language (which is explicitly stated in the specification, Section 7.5).
-+ *  Null and boolean literals are defined as part of both ReservedWord
-+ *  (E5 Section 7.6.1) and Literal (E5 Section 7.8) productions.  Here,
-+ *  null and boolean values have literal tokens, and are not reserved
-+ *  words.
-+ *
-+ *  Decimal literal negative/positive sign is -not- part of DUK_TOK_NUMBER.
-+ *  The number tokens always have a non-negative value.  The unary minus
-+ *  operator in "-1.0" is optimized during compilation to yield a single
-+ *  negative constant.
-+ *
-+ *  Token numbering is free except that reserved words are required to be
-+ *  in a continuous range and in a particular order.  See genstrings.py.
-+ */
-+
-+#define DUK_LEXER_INITCTX(ctx)        duk_lexer_initctx((ctx))
-+
-+#define DUK_LEXER_SETPOINT(ctx,pt)    duk_lexer_setpoint((ctx), (pt))
-+
-+#define DUK_LEXER_GETPOINT(ctx,pt)    do { (pt)->offset = (ctx)->offsets[0]; \
-+                                           (pt)->line = (ctx)->lines[0]; } while (0)
-+
-+/* currently 6 characters of lookup are actually needed (duk_lexer.c) */
-+#define DUK_LEXER_WINDOW_SIZE                     8
-+
-+#define DUK_TOK_MINVAL                            0
-+
-+/* returned after EOF (infinite amount) */
-+#define DUK_TOK_EOF                               0
-+
-+/* line terminator or multi-line comment with internal lineterm (E5 Sections 7.3, 7.4) */
-+#define DUK_TOK_LINETERM                          1
-+
-+/* single-line comment or multi-line comment without internal lineterm (E5 Section 7.4) */
-+#define DUK_TOK_COMMENT                           2
-+
-+/* identifier names (E5 Section 7.6) */
-+#define DUK_TOK_IDENTIFIER                        3
-+
-+/* reserved words: keywords */
-+#define DUK_TOK_START_RESERVED                    4
-+#define DUK_TOK_BREAK                             4
-+#define DUK_TOK_CASE                              5
-+#define DUK_TOK_CATCH                             6
-+#define DUK_TOK_CONTINUE                          7
-+#define DUK_TOK_DEBUGGER                          8
-+#define DUK_TOK_DEFAULT                           9
-+#define DUK_TOK_DELETE                            10
-+#define DUK_TOK_DO                                11
-+#define DUK_TOK_ELSE                              12
-+#define DUK_TOK_FINALLY                           13
-+#define DUK_TOK_FOR                               14
-+#define DUK_TOK_FUNCTION                          15
-+#define DUK_TOK_IF                                16
-+#define DUK_TOK_IN                                17
-+#define DUK_TOK_INSTANCEOF                        18
-+#define DUK_TOK_NEW                               19
-+#define DUK_TOK_RETURN                            20
-+#define DUK_TOK_SWITCH                            21
-+#define DUK_TOK_THIS                              22
-+#define DUK_TOK_THROW                             23
-+#define DUK_TOK_TRY                               24
-+#define DUK_TOK_TYPEOF                            25
-+#define DUK_TOK_VAR                               26
-+#define DUK_TOK_VOID                              27
-+#define DUK_TOK_WHILE                             28
-+#define DUK_TOK_WITH                              29
-+
-+/* reserved words: future reserved words */
-+#define DUK_TOK_CLASS                             30
-+#define DUK_TOK_CONST                             31
-+#define DUK_TOK_ENUM                              32
-+#define DUK_TOK_EXPORT                            33
-+#define DUK_TOK_EXTENDS                           34
-+#define DUK_TOK_IMPORT                            35
-+#define DUK_TOK_SUPER                             36
-+
-+/* "null", "true", and "false" are always reserved words.
-+ * Note that "get" and "set" are not!
-+ */
-+#define DUK_TOK_NULL                              37
-+#define DUK_TOK_TRUE                              38
-+#define DUK_TOK_FALSE                             39
-+
-+/* reserved words: additional future reserved words in strict mode */
-+#define DUK_TOK_START_STRICT_RESERVED             40  /* inclusive */
-+#define DUK_TOK_IMPLEMENTS                        40
-+#define DUK_TOK_INTERFACE                         41
-+#define DUK_TOK_LET                               42
-+#define DUK_TOK_PACKAGE                           43
-+#define DUK_TOK_PRIVATE                           44
-+#define DUK_TOK_PROTECTED                         45
-+#define DUK_TOK_PUBLIC                            46
-+#define DUK_TOK_STATIC                            47
-+#define DUK_TOK_YIELD                             48
-+
-+#define DUK_TOK_END_RESERVED                      49  /* exclusive */
-+
-+/* "get" and "set" are tokens but NOT ReservedWords.  They are currently
-+ * parsed and identifiers and these defines are actually now unused.
-+ */
-+#define DUK_TOK_GET                               49
-+#define DUK_TOK_SET                               50
-+
-+/* punctuators (unlike the spec, also includes "/" and "/=") */
-+#define DUK_TOK_LCURLY                            51
-+#define DUK_TOK_RCURLY                            52
-+#define DUK_TOK_LBRACKET                          53
-+#define DUK_TOK_RBRACKET                          54
-+#define DUK_TOK_LPAREN                            55
-+#define DUK_TOK_RPAREN                            56
-+#define DUK_TOK_PERIOD                            57
-+#define DUK_TOK_SEMICOLON                         58
-+#define DUK_TOK_COMMA                             59
-+#define DUK_TOK_LT                                60
-+#define DUK_TOK_GT                                61
-+#define DUK_TOK_LE                                62
-+#define DUK_TOK_GE                                63
-+#define DUK_TOK_EQ                                64
-+#define DUK_TOK_NEQ                               65
-+#define DUK_TOK_SEQ                               66
-+#define DUK_TOK_SNEQ                              67
-+#define DUK_TOK_ADD                               68
-+#define DUK_TOK_SUB                               69
-+#define DUK_TOK_MUL                               70
-+#define DUK_TOK_DIV                               71
-+#define DUK_TOK_MOD                               72
-+#define DUK_TOK_INCREMENT                         73
-+#define DUK_TOK_DECREMENT                         74
-+#define DUK_TOK_ALSHIFT                           75  /* named "arithmetic" because result is signed */
-+#define DUK_TOK_ARSHIFT                           76
-+#define DUK_TOK_RSHIFT                            77
-+#define DUK_TOK_BAND                              78
-+#define DUK_TOK_BOR                               79
-+#define DUK_TOK_BXOR                              80
-+#define DUK_TOK_LNOT                              81
-+#define DUK_TOK_BNOT                              82
-+#define DUK_TOK_LAND                              83
-+#define DUK_TOK_LOR                               84
-+#define DUK_TOK_QUESTION                          85
-+#define DUK_TOK_COLON                             86
-+#define DUK_TOK_EQUALSIGN                         87
-+#define DUK_TOK_ADD_EQ                            88
-+#define DUK_TOK_SUB_EQ                            89
-+#define DUK_TOK_MUL_EQ                            90
-+#define DUK_TOK_DIV_EQ                            91
-+#define DUK_TOK_MOD_EQ                            92
-+#define DUK_TOK_ALSHIFT_EQ                        93
-+#define DUK_TOK_ARSHIFT_EQ                        94
-+#define DUK_TOK_RSHIFT_EQ                         95
-+#define DUK_TOK_BAND_EQ                           96
-+#define DUK_TOK_BOR_EQ                            97
-+#define DUK_TOK_BXOR_EQ                           98
-+
-+/* literals (E5 Section 7.8), except null, true, false, which are treated
-+ * like reserved words (above).
-+ */
-+#define DUK_TOK_NUMBER                            99
-+#define DUK_TOK_STRING                            100
-+#define DUK_TOK_REGEXP                            101
-+
-+#define DUK_TOK_MAXVAL                            101  /* inclusive */
-+
-+/* Convert heap string index to a token (reserved words) */
-+#define DUK_STRIDX_TO_TOK(x)                        ((x) - DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED)
-+
-+/* Sanity check */
-+#if (DUK_TOK_MAXVAL > 255)
-+#error DUK_TOK_MAXVAL too large, code assumes it fits into 8 bits
-+#endif
-+
-+/* Sanity checks for string and token defines */
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_BREAK) != DUK_TOK_BREAK)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CASE) != DUK_TOK_CASE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CATCH) != DUK_TOK_CATCH)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CONTINUE) != DUK_TOK_CONTINUE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DEBUGGER) != DUK_TOK_DEBUGGER)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DEFAULT) != DUK_TOK_DEFAULT)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DELETE) != DUK_TOK_DELETE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DO) != DUK_TOK_DO)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_ELSE) != DUK_TOK_ELSE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FINALLY) != DUK_TOK_FINALLY)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FOR) != DUK_TOK_FOR)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LC_FUNCTION) != DUK_TOK_FUNCTION)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IF) != DUK_TOK_IF)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IN) != DUK_TOK_IN)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_INSTANCEOF) != DUK_TOK_INSTANCEOF)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_NEW) != DUK_TOK_NEW)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_RETURN) != DUK_TOK_RETURN)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_SWITCH) != DUK_TOK_SWITCH)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_THIS) != DUK_TOK_THIS)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_THROW) != DUK_TOK_THROW)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TRY) != DUK_TOK_TRY)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TYPEOF) != DUK_TOK_TYPEOF)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_VAR) != DUK_TOK_VAR)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_VOID) != DUK_TOK_VOID)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_WHILE) != DUK_TOK_WHILE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_WITH) != DUK_TOK_WITH)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CLASS) != DUK_TOK_CLASS)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CONST) != DUK_TOK_CONST)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_ENUM) != DUK_TOK_ENUM)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_EXPORT) != DUK_TOK_EXPORT)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_EXTENDS) != DUK_TOK_EXTENDS)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IMPORT) != DUK_TOK_IMPORT)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_SUPER) != DUK_TOK_SUPER)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LC_NULL) != DUK_TOK_NULL)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TRUE) != DUK_TOK_TRUE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FALSE) != DUK_TOK_FALSE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IMPLEMENTS) != DUK_TOK_IMPLEMENTS)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_INTERFACE) != DUK_TOK_INTERFACE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LET) != DUK_TOK_LET)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PACKAGE) != DUK_TOK_PACKAGE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PRIVATE) != DUK_TOK_PRIVATE)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PROTECTED) != DUK_TOK_PROTECTED)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PUBLIC) != DUK_TOK_PUBLIC)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_STATIC) != DUK_TOK_STATIC)
-+#error mismatch in token defines
-+#endif
-+#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_YIELD) != DUK_TOK_YIELD)
-+#error mismatch in token defines
-+#endif
-+
-+/* Regexp tokens */
-+#define DUK_RETOK_EOF                              0
-+#define DUK_RETOK_DISJUNCTION                      1
-+#define DUK_RETOK_QUANTIFIER                       2
-+#define DUK_RETOK_ASSERT_START                     3
-+#define DUK_RETOK_ASSERT_END                       4
-+#define DUK_RETOK_ASSERT_WORD_BOUNDARY             5
-+#define DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY         6
-+#define DUK_RETOK_ASSERT_START_POS_LOOKAHEAD       7
-+#define DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD       8
-+#define DUK_RETOK_ATOM_PERIOD                      9
-+#define DUK_RETOK_ATOM_CHAR                        10
-+#define DUK_RETOK_ATOM_DIGIT                       11
-+#define DUK_RETOK_ATOM_NOT_DIGIT                   12
-+#define DUK_RETOK_ATOM_WHITE                       13
-+#define DUK_RETOK_ATOM_NOT_WHITE                   14
-+#define DUK_RETOK_ATOM_WORD_CHAR                   15
-+#define DUK_RETOK_ATOM_NOT_WORD_CHAR               16
-+#define DUK_RETOK_ATOM_BACKREFERENCE               17
-+#define DUK_RETOK_ATOM_START_CAPTURE_GROUP         18
-+#define DUK_RETOK_ATOM_START_NONCAPTURE_GROUP      19
-+#define DUK_RETOK_ATOM_START_CHARCLASS             20
-+#define DUK_RETOK_ATOM_START_CHARCLASS_INVERTED    21
-+#define DUK_RETOK_ATOM_END_GROUP                   22
-+
-+/* constants for duk_lexer_ctx.buf */
-+#define DUK_LEXER_TEMP_BUF_INITIAL                 64
-+#define DUK_LEXER_TEMP_BUF_LIMIT                   256
-+
-+/* A token value.  Can be memcpy()'d, but note that slot1/slot2 values are on the valstack. */
-+struct duk_token {
-+	duk_small_int_t t;            /* token type (with reserved word identification) */
-+	duk_small_int_t t_nores;      /* token type (with reserved words as DUK_TOK_IDENTIFER) */
-+	duk_double_t num;             /* numeric value of token */
-+	duk_hstring *str1;            /* string 1 of token (borrowed, stored to ctx->slot1_idx) */
-+	duk_hstring *str2;            /* string 2 of token (borrowed, stored to ctx->slot1_idx) */
-+	duk_size_t start_offset;      /* start byte offset of token in lexer input */
-+	duk_int_t start_line;         /* start line of token (first char) */
-+	duk_int_t num_escapes;        /* number of escapes and line continuations (for directive prologue) */
-+	duk_bool_t lineterm;          /* token was preceded by a lineterm */
-+	duk_bool_t allow_auto_semi;   /* token allows automatic semicolon insertion (eof or preceded by newline) */
-+};
-+
-+#define DUK_RE_QUANTIFIER_INFINITE         ((duk_uint32_t) 0xffffffffUL)
-+
-+/* A regexp token value. */
-+struct duk_re_token {
-+	duk_small_int_t t;           /* token type */
-+	duk_small_int_t greedy;
-+	duk_uint_fast32_t num;       /* numeric value (character, count) */
-+	duk_uint_fast32_t qmin;
-+	duk_uint_fast32_t qmax;
-+};
-+
-+/* A structure for 'snapshotting' a point for rewinding */
-+struct duk_lexer_point {
-+	duk_size_t offset;
-+	duk_int_t line;
-+};
-+
-+/* Lexer context.  Same context is used for Ecmascript and Regexp parsing. */
-+struct duk_lexer_ctx {
-+	duk_hthread *thr;                              /* thread; minimizes argument passing */
-+
-+	const duk_uint8_t *input;                      /* input string (may be a user pointer) */
-+	duk_size_t input_length;                       /* input byte length */
-+	duk_size_t input_offset;                       /* input offset for window leading edge (not window[0]) */
-+
-+	duk_codepoint_t window[DUK_LEXER_WINDOW_SIZE]; /* window of unicode code points */
-+	duk_size_t offsets[DUK_LEXER_WINDOW_SIZE];     /* input byte offset for each char */
-+	duk_int_t lines[DUK_LEXER_WINDOW_SIZE];        /* input lines for each char */
-+	duk_int_t input_line;                          /* input linenumber at input_offset (not window[0]), init to 1 */
-+	duk_idx_t slot1_idx;                           /* valstack slot for 1st token value */
-+	duk_idx_t slot2_idx;                           /* valstack slot for 2nd token value */
-+	duk_idx_t buf_idx;                             /* valstack slot for temp buffer */
-+	duk_hbuffer_dynamic *buf;                      /* temp accumulation buffer (on valstack) */
-+
-+	duk_int_t token_count;                         /* number of tokens parsed */
-+	duk_int_t token_limit;                         /* maximum token count before error (sanity backstop) */
-+};
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+DUK_INTERNAL_DECL void duk_lexer_initctx(duk_lexer_ctx *lex_ctx);
-+
-+DUK_INTERNAL_DECL void duk_lexer_setpoint(duk_lexer_ctx *lex_ctx, duk_lexer_point *pt);
-+
-+DUK_INTERNAL_DECL
-+void duk_lexer_parse_js_input_element(duk_lexer_ctx *lex_ctx,
-+                                      duk_token *out_token,
-+                                      duk_bool_t strict_mode,
-+                                      duk_bool_t regexp_mode);
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+DUK_INTERNAL_DECL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token *out_token);
-+DUK_INTERNAL_DECL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata);
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+
-+#endif  /* DUK_LEXER_H_INCLUDED */
-+#line 1 "duk_js_compiler.h"
-+/*
-+ *  Ecmascript compiler.
-+ */
-+
-+#ifndef DUK_JS_COMPILER_H_INCLUDED
-+#define DUK_JS_COMPILER_H_INCLUDED
-+
-+/* ecmascript compiler limits */
-+#if defined(DUK_USE_DEEP_C_STACK)
-+#define DUK_COMPILER_RECURSION_LIMIT       2500L
-+#else
-+#define DUK_COMPILER_RECURSION_LIMIT       50L
-+#endif
-+#define DUK_COMPILER_TOKEN_LIMIT           100000000L  /* 1e8: protects against deeply nested inner functions */
-+
-+/* maximum loopcount for peephole optimization */
-+#define DUK_COMPILER_PEEPHOLE_MAXITER      3
-+
-+/* maximum bytecode length in instructions */
-+#define DUK_COMPILER_MAX_BYTECODE_LENGTH   (256L * 1024L * 1024L)  /* 1 GB */
-+
-+/*
-+ *  Compiler intermediate values
-+ *
-+ *  Intermediate values describe either plain values (e.g. strings or
-+ *  numbers) or binary operations which have not yet been coerced into
-+ *  either a left-hand-side or right-hand-side role (e.g. object property).
-+ */
-+
-+#define DUK_IVAL_NONE          0   /* no value */
-+#define DUK_IVAL_PLAIN         1   /* register, constant, or value */
-+#define DUK_IVAL_ARITH         2   /* binary arithmetic; DUK_OP_ADD, DUK_OP_EQ, other binary ops */
-+#define DUK_IVAL_ARITH_EXTRAOP 3   /* binary arithmetic using extraops; DUK_EXTRAOP_INSTOF etc */
-+#define DUK_IVAL_PROP          4   /* property access */
-+#define DUK_IVAL_VAR           5   /* variable access */
-+
-+#define DUK_ISPEC_NONE         0   /* no value */
-+#define DUK_ISPEC_VALUE        1   /* value resides in 'valstack_idx' */
-+#define DUK_ISPEC_REGCONST     2   /* value resides in a register or constant */
-+
-+/* bit mask which indicates that a regconst is a constant instead of a register */
-+#define DUK_JS_CONST_MARKER    0x80000000UL
-+
-+/* type to represent a reg/const reference during compilation */
-+typedef duk_uint32_t duk_regconst_t;
-+
-+/* type to represent a straight register reference, with <0 indicating none */
-+typedef duk_int32_t duk_reg_t;
-+
-+typedef struct {
-+	duk_small_uint_t t;          /* DUK_ISPEC_XXX */
-+	duk_regconst_t regconst;
-+	duk_idx_t valstack_idx;      /* always set; points to a reserved valstack slot */
-+} duk_ispec;
-+
-+typedef struct {
-+	/*
-+	 *  PLAIN: x1
-+	 *  ARITH: x1 <op> x2
-+	 *  PROP: x1.x2
-+	 *  VAR: x1 (name)
-+	 */
-+
-+	/* XXX: can be optimized for smaller footprint esp. on 32-bit environments */
-+	duk_small_uint_t t;          /* DUK_IVAL_XXX */
-+	duk_small_uint_t op;         /* bytecode opcode (or extraop) for binary ops */
-+	duk_ispec x1;
-+	duk_ispec x2;
-+} duk_ivalue;
-+
-+/*
-+ *  Bytecode instruction representation during compilation
-+ *
-+ *  Contains the actual instruction and (optionally) debug info.
-+ */
-+
-+struct duk_compiler_instr {
-+	duk_instr_t ins;
-+#if defined(DUK_USE_PC2LINE)
-+	duk_uint32_t line;
-+#endif
-+};
-+
-+/*
-+ *  Compiler state
-+ */
-+
-+#define DUK_LABEL_FLAG_ALLOW_BREAK       (1 << 0)
-+#define DUK_LABEL_FLAG_ALLOW_CONTINUE    (1 << 1)
-+
-+#define DUK_DECL_TYPE_VAR                0
-+#define DUK_DECL_TYPE_FUNC               1
-+
-+/* XXX: optimize to 16 bytes */
-+typedef struct {
-+	duk_small_uint_t flags;
-+	duk_int_t label_id;          /* numeric label_id (-1 reserved as marker) */
-+	duk_hstring *h_label;        /* borrowed label name */
-+	duk_int_t catch_depth;       /* catch depth at point of definition */
-+	duk_int_t pc_label;          /* pc of label statement:
-+	                              * pc+1: break jump site
-+	                              * pc+2: continue jump site
-+	                              */
-+
-+	/* Fast jumps (which avoid longjmp) jump directly to the jump sites
-+	 * which are always known even while the iteration/switch statement
-+	 * is still being parsed.  A final peephole pass "straightens out"
-+	 * the jumps.
-+	 */
-+} duk_labelinfo;
-+
-+/* Compiling state of one function, eventually converted to duk_hcompiledfunction */
-+struct duk_compiler_func {
-+	/* These pointers are at the start of the struct so that they pack
-+	 * nicely.  Mixing pointers and integer values is bad on some
-+	 * platforms (e.g. if int is 32 bits and pointers are 64 bits).
-+	 */
-+
-+	duk_hstring *h_name;                /* function name (borrowed reference), ends up in _name */
-+	duk_hbuffer_dynamic *h_code;        /* C array of duk_compiler_instr */
-+	duk_hobject *h_consts;              /* array */
-+	duk_hobject *h_funcs;               /* array of function templates: [func1, offset1, line1, func2, offset2, line2]
-+	                                     * offset/line points to closing brace to allow skipping on pass 2
-+	                                     */
-+	duk_hobject *h_decls;               /* array of declarations: [ name1, val1, name2, val2, ... ]
-+	                                     * valN = (typeN) | (fnum << 8), where fnum is inner func number (0 for vars)
-+	                                     * record function and variable declarations in pass 1
-+	                                     */
-+	duk_hobject *h_labelnames;          /* array of active label names */
-+	duk_hbuffer_dynamic *h_labelinfos;  /* C array of duk_labelinfo */
-+	duk_hobject *h_argnames;            /* array of formal argument names (-> _Formals) */
-+	duk_hobject *h_varmap;              /* variable map for pass 2 (identifier -> register number or null (unmapped)) */
-+
-+	/* value stack indices for tracking objects */
-+	duk_idx_t code_idx;
-+	duk_idx_t consts_idx;
-+	duk_idx_t funcs_idx;
-+	duk_idx_t decls_idx;
-+	duk_idx_t labelnames_idx;
-+	duk_idx_t labelinfos_idx;
-+	duk_idx_t argnames_idx;
-+	duk_idx_t varmap_idx;
-+
-+	/* temp reg handling */
-+	duk_reg_t temp_first;               /* first register that is a temporary (below: variables) */
-+	duk_reg_t temp_next;                /* next temporary register to allocate */
-+	duk_reg_t temp_max;                 /* highest value of temp_reg (temp_max - 1 is highest used reg) */
-+
-+	/* shuffle registers if large number of regs/consts */
-+	duk_reg_t shuffle1;
-+	duk_reg_t shuffle2;
-+	duk_reg_t shuffle3;
-+
-+	/* stats for current expression being parsed */
-+	duk_int_t nud_count;
-+	duk_int_t led_count;
-+	duk_int_t paren_level;              /* parenthesis count, 0 = top level */
-+	duk_bool_t expr_lhs;                /* expression is left-hand-side compatible */
-+	duk_bool_t allow_in;                /* current paren level allows 'in' token */
-+
-+	/* misc */
-+	duk_int_t stmt_next;                /* statement id allocation (running counter) */
-+	duk_int_t label_next;               /* label id allocation (running counter) */
-+	duk_int_t catch_depth;              /* catch stack depth */
-+	duk_int_t with_depth;               /* with stack depth (affects identifier lookups) */
-+	duk_int_t fnum_next;                /* inner function numbering */
-+	duk_int_t num_formals;              /* number of formal arguments */
-+	duk_reg_t reg_stmt_value;           /* register for writing value of 'non-empty' statements (global or eval code), -1 is marker */
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	duk_int_t min_line;                 /* XXX: typing (duk_hcompiledfunction has duk_uint32_t) */
-+	duk_int_t max_line;
-+#endif
-+
-+	/* status booleans */
-+	duk_bool_t is_function;             /* is an actual function (not global/eval code) */
-+	duk_bool_t is_eval;                 /* is eval code */
-+	duk_bool_t is_global;               /* is global code */
-+	duk_bool_t is_setget;               /* is a setter/getter */
-+	duk_bool_t is_decl;                 /* is a function declaration (as opposed to function expression) */
-+	duk_bool_t is_strict;               /* function is strict */
-+	duk_bool_t is_notail;               /* function must not be tailcalled */
-+	duk_bool_t in_directive_prologue;   /* parsing in "directive prologue", recognize directives */
-+	duk_bool_t in_scanning;             /* parsing in "scanning" phase (first pass) */
-+	duk_bool_t may_direct_eval;         /* function may call direct eval */
-+	duk_bool_t id_access_arguments;     /* function refers to 'arguments' identifier */
-+	duk_bool_t id_access_slow;          /* function makes one or more slow path accesses */
-+	duk_bool_t is_arguments_shadowed;   /* argument/function declaration shadows 'arguments' */
-+	duk_bool_t needs_shuffle;           /* function needs shuffle registers */
-+	duk_bool_t reject_regexp_in_adv;    /* reject RegExp literal on next advance() call; needed for handling IdentifierName productions */
-+};
-+
-+struct duk_compiler_ctx {
-+	duk_hthread *thr;
-+
-+	/* filename being compiled (ends up in functions' '_filename' property) */
-+	duk_hstring *h_filename;            /* borrowed reference */
-+
-+	/* lexing (tokenization) state (contains two valstack slot indices) */
-+	duk_lexer_ctx lex;
-+
-+	/* current and previous token for parsing */
-+	duk_token prev_token;
-+	duk_token curr_token;
-+	duk_idx_t tok11_idx;                /* curr_token slot1 (matches 'lex' slot1_idx) */
-+	duk_idx_t tok12_idx;                /* curr_token slot2 (matches 'lex' slot2_idx) */
-+	duk_idx_t tok21_idx;                /* prev_token slot1 */
-+	duk_idx_t tok22_idx;                /* prev_token slot2 */
-+
-+	/* recursion limit */
-+	duk_int_t recursion_depth;
-+	duk_int_t recursion_limit;
-+
-+	/* code emission temporary */
-+	duk_int_t emit_jumpslot_pc;
-+
-+	/* current function being compiled (embedded instead of pointer for more compact access) */
-+	duk_compiler_func curr_func;
-+};
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+#define DUK_JS_COMPILE_FLAG_EVAL      (1 << 0)  /* source is eval code (not program) */
-+#define DUK_JS_COMPILE_FLAG_STRICT    (1 << 1)  /* strict outer context */
-+#define DUK_JS_COMPILE_FLAG_FUNCEXPR  (1 << 2)  /* source is a function expression (used for Function constructor) */
-+
-+DUK_INTERNAL_DECL void duk_js_compile(duk_hthread *thr, const duk_uint8_t *src_buffer, duk_size_t src_length, duk_small_uint_t flags);
-+
-+#endif  /* DUK_JS_COMPILER_H_INCLUDED */
-+#line 1 "duk_regexp.h"
-+/*
-+ *  Regular expression structs, constants, and bytecode defines.
-+ */
-+
-+#ifndef DUK_REGEXP_H_INCLUDED
-+#define DUK_REGEXP_H_INCLUDED
-+
-+/* maximum bytecode copies for {n,m} quantifiers */
-+#define DUK_RE_MAX_ATOM_COPIES             1000
-+
-+/* regexp compilation limits */
-+#if defined(DUK_USE_DEEP_C_STACK)
-+#define DUK_RE_COMPILE_RECURSION_LIMIT     10000
-+#else
-+#define DUK_RE_COMPILE_RECURSION_LIMIT     100
-+#endif
-+#define DUK_RE_COMPILE_TOKEN_LIMIT         100000000L   /* 1e8 */
-+
-+/* regexp execution limits */
-+#if defined(DUK_USE_DEEP_C_STACK)
-+#define DUK_RE_EXECUTE_RECURSION_LIMIT     10000
-+#else
-+#define DUK_RE_EXECUTE_RECURSION_LIMIT     100
-+#endif
-+#define DUK_RE_EXECUTE_STEPS_LIMIT         1000000000L  /* 1e9 */
-+
-+/* regexp opcodes */
-+#define DUK_REOP_MATCH                     1
-+#define DUK_REOP_CHAR                      2
-+#define DUK_REOP_PERIOD                    3
-+#define DUK_REOP_RANGES                    4
-+#define DUK_REOP_INVRANGES                 5
-+#define DUK_REOP_JUMP                      6
-+#define DUK_REOP_SPLIT1                    7
-+#define DUK_REOP_SPLIT2                    8
-+#define DUK_REOP_SQMINIMAL                 9
-+#define DUK_REOP_SQGREEDY                  10
-+#define DUK_REOP_SAVE                      11
-+#define DUK_REOP_WIPERANGE                 12
-+#define DUK_REOP_LOOKPOS                   13
-+#define DUK_REOP_LOOKNEG                   14
-+#define DUK_REOP_BACKREFERENCE             15
-+#define DUK_REOP_ASSERT_START              16
-+#define DUK_REOP_ASSERT_END                17
-+#define DUK_REOP_ASSERT_WORD_BOUNDARY      18
-+#define DUK_REOP_ASSERT_NOT_WORD_BOUNDARY  19
-+
-+/* flags */
-+#define DUK_RE_FLAG_GLOBAL                 (1 << 0)
-+#define DUK_RE_FLAG_IGNORE_CASE            (1 << 1)
-+#define DUK_RE_FLAG_MULTILINE              (1 << 2)
-+
-+struct duk_re_matcher_ctx {
-+	duk_hthread *thr;
-+
-+	duk_uint32_t re_flags;
-+	const duk_uint8_t *input;
-+	const duk_uint8_t *input_end;
-+	const duk_uint8_t *bytecode;
-+	const duk_uint8_t *bytecode_end;
-+	const duk_uint8_t **saved;  /* allocated from valstack (fixed buffer) */
-+	duk_uint32_t nsaved;
-+	duk_uint32_t recursion_depth;
-+	duk_uint32_t recursion_limit;
-+	duk_uint32_t steps_count;
-+	duk_uint32_t steps_limit;
-+};
-+
-+struct duk_re_compiler_ctx {
-+	duk_hthread *thr;
-+
-+	duk_uint32_t re_flags;
-+	duk_lexer_ctx lex;
-+	duk_re_token curr_token;
-+	duk_hbuffer_dynamic *buf;
-+	duk_uint32_t captures;  /* highest capture number emitted so far (used as: ++captures) */
-+	duk_uint32_t highest_backref;
-+	duk_uint32_t recursion_depth;
-+	duk_uint32_t recursion_limit;
-+	duk_uint32_t nranges;  /* internal temporary value, used for char classes */
-+};
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+DUK_INTERNAL_DECL void duk_regexp_compile(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_regexp_create_instance(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_regexp_match(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_regexp_match_force_global(duk_hthread *thr);  /* hacky helper for String.prototype.split() */
-+
-+#endif  /* DUK_REGEXP_H_INCLUDED */
-+#line 1 "duk_tval.h"
-+/*
-+ *  Tagged type definition (duk_tval) and accessor macros.
-+ *
-+ *  Access all fields through the accessor macros, as the representation
-+ *  is quite tricky.
-+ *
-+ *  There are two packed type alternatives: an 8-byte representation
-+ *  based on an IEEE double (preferred for compactness), and a 12-byte
-+ *  representation (portability).  The latter is needed also in e.g.
-+ *  64-bit environments (it usually pads to 16 bytes per value).
-+ *
-+ *  Selecting the tagged type format involves many trade-offs (memory
-+ *  use, size and performance of generated code, portability, etc),
-+ *  see doc/types.txt for a detailed discussion (especially of how the
-+ *  IEEE double format is used to pack tagged values).
-+ *
-+ *  NB: because macro arguments are often expressions, macros should
-+ *  avoid evaluating their argument more than once.
-+ */
-+
-+#ifndef DUK_TVAL_H_INCLUDED
-+#define DUK_TVAL_H_INCLUDED
-+
-+/* sanity */
-+#if !defined(DUK_USE_DOUBLE_LE) && !defined(DUK_USE_DOUBLE_ME) && !defined(DUK_USE_DOUBLE_BE)
-+#error unsupported: cannot determine byte order variant
-+#endif
-+
-+#ifdef DUK_USE_PACKED_TVAL
-+/* ======================================================================== */
-+
-+/*
-+ *  Packed 8-byte representation
-+ */
-+
-+/* sanity */
-+#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE)
-+#error packed representation not supported
-+#endif
-+
-+/* use duk_double_union as duk_tval directly */
-+typedef union duk_double_union duk_tval;
-+
-+/* tags */
-+#define DUK_TAG_NORMALIZED_NAN    0x7ff8UL   /* the NaN variant we use */
-+/* avoid tag 0xfff0, no risk of confusion with negative infinity */
-+#if defined(DUK_USE_FASTINT)
-+#define DUK_TAG_FASTINT           0xfff1UL   /* embed: integer value */
-+#endif
-+#define DUK_TAG_UNDEFINED         0xfff2UL   /* embed: 0 or 1 (normal or unused) */
-+#define DUK_TAG_NULL              0xfff3UL   /* embed: nothing */
-+#define DUK_TAG_BOOLEAN           0xfff4UL   /* embed: 0 or 1 (false or true) */
-+/* DUK_TAG_NUMBER would logically go here, but it has multiple 'tags' */
-+#define DUK_TAG_POINTER           0xfff5UL   /* embed: void ptr */
-+#define DUK_TAG_LIGHTFUNC         0xfff6UL   /* embed: func ptr */
-+#define DUK_TAG_STRING            0xfff7UL   /* embed: duk_hstring ptr */
-+#define DUK_TAG_OBJECT            0xfff8UL   /* embed: duk_hobject ptr */
-+#define DUK_TAG_BUFFER            0xfff9UL   /* embed: duk_hbuffer ptr */
-+
-+/* for convenience */
-+#define DUK_XTAG_UNDEFINED_ACTUAL 0xfff20000UL
-+#define DUK_XTAG_UNDEFINED_UNUSED 0xfff20001UL
-+#define DUK_XTAG_NULL             0xfff30000UL
-+#define DUK_XTAG_BOOLEAN_FALSE    0xfff40000UL
-+#define DUK_XTAG_BOOLEAN_TRUE     0xfff40001UL
-+
-+/* two casts to avoid gcc warning: "warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]" */
-+#ifdef DUK_USE_64BIT_OPS
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag)  do { \
-+		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) (tag)) << 16) | (((duk_uint64_t) (duk_uint32_t) (h)) << 32); \
-+	} while (0)
-+#else
-+#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag)  do { \
-+		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) (tag)) << 48) | ((duk_uint64_t) (duk_uint32_t) (h)); \
-+	} while (0)
-+#endif
-+#else  /* DUK_USE_64BIT_OPS */
-+#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag)  do { \
-+		(v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) (tag)) << 16; \
-+		(v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (h); \
-+	} while (0)
-+#endif  /* DUK_USE_64BIT_OPS */
-+
-+#ifdef DUK_USE_64BIT_OPS
-+/* Double casting for pointer to avoid gcc warning (cast from pointer to integer of different size) */
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags)  do { \
-+		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_LIGHTFUNC) << 16) | \
-+		                             ((duk_uint64_t) (flags)) | \
-+		                             (((duk_uint64_t) (duk_uint32_t) (fp)) << 32); \
-+	} while (0)
-+#else
-+#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags)  do { \
-+		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_LIGHTFUNC) << 48) | \
-+		                             (((duk_uint64_t) (flags)) << 32) | \
-+		                             ((duk_uint64_t) (duk_uint32_t) (fp)); \
-+	} while (0)
-+#endif
-+#else  /* DUK_USE_64BIT_OPS */
-+#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags)  do { \
-+		(v)->ui[DUK_DBL_IDX_UI0] = (((duk_uint32_t) DUK_TAG_LIGHTFUNC) << 16) | ((duk_uint32_t) (flags)); \
-+		(v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (fp); \
-+	} while (0)
-+#endif  /* DUK_USE_64BIT_OPS */
-+
-+#if defined(DUK_USE_FASTINT)
-+/* Note: masking is done for 'i' to deal with negative numbers correctly */
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK__TVAL_SET_FASTINT(v,i)  do { \
-+		(v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) DUK_TAG_FASTINT) << 16 | (((duk_uint32_t) ((i) >> 32)) & 0x0000ffffUL); \
-+		(v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (i); \
-+	} while (0)
-+#define DUK__TVAL_SET_FASTINT_U32(v,i)  do { \
-+		(v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) DUK_TAG_FASTINT) << 16; \
-+		(v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (i); \
-+	} while (0)
-+#else
-+#define DUK__TVAL_SET_FASTINT(v,i)  do { \
-+		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (((duk_uint64_t) (i)) & 0x0000ffffffffffffULL); \
-+	} while (0)
-+#define DUK__TVAL_SET_FASTINT_U32(v,i)  do { \
-+		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (duk_uint64_t) (i); \
-+	} while (0)
-+#endif
-+
-+#define DUK__TVAL_SET_FASTINT_I32(v,i)  do { \
-+		duk_int64_t duk__tmp = (duk_int64_t) (i); \
-+		DUK_TVAL_SET_FASTINT((v), duk__tmp); \
-+	} while (0)
-+
-+/* XXX: clumsy sign extend and masking of 16 topmost bits */
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK__TVAL_GET_FASTINT(v)      (((duk_int64_t) ((((duk_uint64_t) (v)->ui[DUK_DBL_IDX_UI0]) << 32) | ((duk_uint64_t) (v)->ui[DUK_DBL_IDX_UI1]))) << 16 >> 16)
-+#else
-+#define DUK__TVAL_GET_FASTINT(v)      ((((duk_int64_t) (v)->ull[DUK_DBL_IDX_ULL0]) << 16) >> 16)
-+#endif
-+#define DUK__TVAL_GET_FASTINT_U32(v)  ((v)->ui[DUK_DBL_IDX_UI1])
-+#define DUK__TVAL_GET_FASTINT_I32(v)  ((duk_int32_t) (v)->ui[DUK_DBL_IDX_UI1])
-+#endif  /* DUK_USE_FASTINT */
-+
-+#define DUK_TVAL_SET_UNDEFINED_ACTUAL(v)    DUK_DBLUNION_SET_HIGH32((v), DUK_XTAG_UNDEFINED_ACTUAL)
-+#define DUK_TVAL_SET_UNDEFINED_UNUSED(v)    DUK_DBLUNION_SET_HIGH32((v), DUK_XTAG_UNDEFINED_UNUSED)
-+
-+/* Note: 16-bit initializer suffices (unlike for undefined/boolean) */
-+#define DUK_TVAL_SET_NULL(v)  do { \
-+		(v)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_NULL; \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_BOOLEAN(v,val)         DUK_DBLUNION_SET_HIGH32((v), (((duk_uint32_t) DUK_TAG_BOOLEAN) << 16) | ((duk_uint32_t) (val)))
-+
-+#define DUK_TVAL_SET_NAN(v)                 DUK_DBLUNION_SET_NAN_FULL((v))
-+
-+/* Assumes that caller has normalized NaNs, otherwise trouble ahead. */
-+#if defined(DUK_USE_FASTINT)
-+#define DUK_TVAL_SET_DOUBLE(v,d)            DUK_DBLUNION_SET_DOUBLE((v), (d))
-+#define DUK_TVAL_SET_FASTINT(v,i)           DUK__TVAL_SET_FASTINT((v), (i))
-+#define DUK_TVAL_SET_FASTINT_I32(v,i)       DUK__TVAL_SET_FASTINT_I32((v), (i))
-+#define DUK_TVAL_SET_FASTINT_U32(v,i)       DUK__TVAL_SET_FASTINT_U32((v), (i))
-+#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d)    duk_tval_set_number_chkfast((v), (d))
-+#define DUK_TVAL_SET_NUMBER(v,d)            DUK_DBLUNION_SET_DOUBLE((v), (d))
-+#define DUK_TVAL_CHKFAST_INPLACE(v)  do { \
-+		duk_tval *duk__tv; \
-+		duk_double_t duk__d; \
-+		duk__tv = (v); \
-+		if (DUK_TVAL_IS_DOUBLE(duk__tv)) { \
-+			duk__d = DUK_TVAL_GET_DOUBLE(duk__tv); \
-+			DUK_TVAL_SET_NUMBER_CHKFAST(duk__tv, duk__d); \
-+		} \
-+	} while (0)
-+#else
-+#define DUK_TVAL_SET_NUMBER(v,d)            DUK_DBLUNION_SET_DOUBLE((v), (d))
-+#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d)    DUK_TVAL_SET_NUMBER((v), (d))
-+#define DUK_TVAL_SET_DOUBLE(v,d)            DUK_TVAL_SET_NUMBER((v), (d))
-+#define DUK_TVAL_CHKFAST_INPLACE(v)  do { } while (0)
-+#endif
-+
-+#define DUK_TVAL_SET_LIGHTFUNC(v,fp,flags)  DUK__TVAL_SET_LIGHTFUNC((v), (fp), (flags))
-+#define DUK_TVAL_SET_STRING(v,h)            DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_STRING)
-+#define DUK_TVAL_SET_OBJECT(v,h)            DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_OBJECT)
-+#define DUK_TVAL_SET_BUFFER(v,h)            DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_BUFFER)
-+#define DUK_TVAL_SET_POINTER(v,p)           DUK__TVAL_SET_TAGGEDPOINTER((v), (p), DUK_TAG_POINTER)
-+
-+#define DUK_TVAL_SET_TVAL(v,x)              do { *(v) = *(x); } while (0)
-+
-+/* getters */
-+#define DUK_TVAL_GET_BOOLEAN(v)             ((int) (v)->us[DUK_DBL_IDX_US1])
-+#if defined(DUK_USE_FASTINT)
-+#define DUK_TVAL_GET_DOUBLE(v)              ((v)->d)
-+#define DUK_TVAL_GET_FASTINT(v)             DUK__TVAL_GET_FASTINT((v))
-+#define DUK_TVAL_GET_FASTINT_U32(v)         DUK__TVAL_GET_FASTINT_U32((v))
-+#define DUK_TVAL_GET_FASTINT_I32(v)         DUK__TVAL_GET_FASTINT_I32((v))
-+#define DUK_TVAL_GET_NUMBER(v)              duk_tval_get_number_packed((v))
-+#else
-+#define DUK_TVAL_GET_NUMBER(v)              ((v)->d)
-+#define DUK_TVAL_GET_DOUBLE(v)              ((v)->d)
-+#endif
-+#define DUK_TVAL_GET_LIGHTFUNC(v,out_fp,out_flags)  do { \
-+		(out_flags) = (v)->ui[DUK_DBL_IDX_UI0] & 0xffffUL; \
-+		(out_fp) = (duk_c_function) (v)->ui[DUK_DBL_IDX_UI1]; \
-+	} while (0)
-+#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(v)   ((duk_c_function) ((v)->ui[DUK_DBL_IDX_UI1]))
-+#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(v)     (((int) (v)->ui[DUK_DBL_IDX_UI0]) & 0xffffUL)
-+#define DUK_TVAL_GET_STRING(v)              ((duk_hstring *) (v)->vp[DUK_DBL_IDX_VP1])
-+#define DUK_TVAL_GET_OBJECT(v)              ((duk_hobject *) (v)->vp[DUK_DBL_IDX_VP1])
-+#define DUK_TVAL_GET_BUFFER(v)              ((duk_hbuffer *) (v)->vp[DUK_DBL_IDX_VP1])
-+#define DUK_TVAL_GET_POINTER(v)             ((void *) (v)->vp[DUK_DBL_IDX_VP1])
-+#define DUK_TVAL_GET_HEAPHDR(v)             ((duk_heaphdr *) (v)->vp[DUK_DBL_IDX_VP1])
-+
-+/* decoding */
-+#define DUK_TVAL_GET_TAG(v)                 ((duk_small_uint_t) (v)->us[DUK_DBL_IDX_US0])
-+
-+#define DUK_TVAL_IS_UNDEFINED(v)            (DUK_TVAL_GET_TAG((v)) == DUK_TAG_UNDEFINED)
-+#define DUK_TVAL_IS_UNDEFINED_ACTUAL(v)     ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_UNDEFINED_ACTUAL)
-+#define DUK_TVAL_IS_UNDEFINED_UNUSED(v)     ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_UNDEFINED_UNUSED)
-+#define DUK_TVAL_IS_NULL(v)                 (DUK_TVAL_GET_TAG((v)) == DUK_TAG_NULL)
-+#define DUK_TVAL_IS_BOOLEAN(v)              (DUK_TVAL_GET_TAG((v)) == DUK_TAG_BOOLEAN)
-+#define DUK_TVAL_IS_BOOLEAN_TRUE(v)         ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_TRUE)
-+#define DUK_TVAL_IS_BOOLEAN_FALSE(v)        ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_FALSE)
-+#define DUK_TVAL_IS_LIGHTFUNC(v)            (DUK_TVAL_GET_TAG((v)) == DUK_TAG_LIGHTFUNC)
-+#define DUK_TVAL_IS_STRING(v)               (DUK_TVAL_GET_TAG((v)) == DUK_TAG_STRING)
-+#define DUK_TVAL_IS_OBJECT(v)               (DUK_TVAL_GET_TAG((v)) == DUK_TAG_OBJECT)
-+#define DUK_TVAL_IS_BUFFER(v)               (DUK_TVAL_GET_TAG((v)) == DUK_TAG_BUFFER)
-+#define DUK_TVAL_IS_POINTER(v)              (DUK_TVAL_GET_TAG((v)) == DUK_TAG_POINTER)
-+#if defined(DUK_USE_FASTINT)
-+/* 0xfff0 is -Infinity */
-+#define DUK_TVAL_IS_DOUBLE(v)               (DUK_TVAL_GET_TAG((v)) <= 0xfff0UL)
-+#define DUK_TVAL_IS_FASTINT(v)              (DUK_TVAL_GET_TAG((v)) == DUK_TAG_FASTINT)
-+#define DUK_TVAL_IS_NUMBER(v)               (DUK_TVAL_GET_TAG((v)) <= 0xfff1UL)
-+#else
-+#define DUK_TVAL_IS_NUMBER(v)               (DUK_TVAL_GET_TAG((v)) <= 0xfff0UL)
-+#define DUK_TVAL_IS_DOUBLE(v)               DUK_TVAL_IS_NUMBER((v))
-+#endif
-+
-+#define DUK_TVAL_IS_HEAP_ALLOCATED(v)       (DUK_TVAL_GET_TAG((v)) >= DUK_TAG_STRING)
-+
-+#if defined(DUK_USE_FASTINT)
-+/* Inlining is only effective in a single file build. */
-+DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_packed(duk_tval *tv);
-+#endif
-+
-+#else  /* DUK_USE_PACKED_TVAL */
-+/* ======================================================================== */
-+
-+/*
-+ *  Portable 12-byte representation
-+ */
-+
-+/* Note: not initializing all bytes is normally not an issue: Duktape won't
-+ * read or use the uninitialized bytes so valgrind won't issue warnings.
-+ * In some special cases a harmless valgrind warning may be issued though.
-+ * For example, the DumpHeap debugger command writes out a compiled function's
-+ * 'data' area as is, including any uninitialized bytes, which causes a
-+ * valgrind warning.
-+ */
-+
-+typedef struct duk_tval_struct duk_tval;
-+
-+struct duk_tval_struct {
-+	duk_small_uint_t t;
-+	duk_small_uint_t v_extra;
-+	union {
-+		duk_double_t d;
-+		duk_small_int_t i;
-+#if defined(DUK_USE_FASTINT)
-+		duk_int64_t fi;  /* if present, forces 16-byte duk_tval */
-+#endif
-+		void *voidptr;
-+		duk_hstring *hstring;
-+		duk_hobject *hobject;
-+		duk_hcompiledfunction *hcompiledfunction;
-+		duk_hnativefunction *hnativefunction;
-+		duk_hthread *hthread;
-+		duk_hbuffer *hbuffer;
-+		duk_heaphdr *heaphdr;
-+		duk_c_function lightfunc;
-+	} v;
-+};
-+
-+#define DUK__TAG_NUMBER               0  /* not exposed */
-+#if defined(DUK_USE_FASTINT)
-+#define DUK_TAG_FASTINT               1
-+#endif
-+#define DUK_TAG_UNDEFINED             2
-+#define DUK_TAG_NULL                  3
-+#define DUK_TAG_BOOLEAN               4
-+#define DUK_TAG_POINTER               5
-+#define DUK_TAG_LIGHTFUNC             6
-+#define DUK_TAG_STRING                7
-+#define DUK_TAG_OBJECT                8
-+#define DUK_TAG_BUFFER                9
-+
-+/* DUK__TAG_NUMBER is intentionally first, as it is the default clause in code
-+ * to support the 8-byte representation.  Further, it is a non-heap-allocated
-+ * type so it should come before DUK_TAG_STRING.  Finally, it should not break
-+ * the tag value ranges covered by case-clauses in a switch-case.
-+ */
-+
-+/* setters */
-+#define DUK_TVAL_SET_UNDEFINED_ACTUAL(tv)  do { \
-+		(tv)->t = DUK_TAG_UNDEFINED; \
-+		(tv)->v.i = 0; \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_UNDEFINED_UNUSED(tv)  do { \
-+		(tv)->t = DUK_TAG_UNDEFINED; \
-+		(tv)->v.i = 1; \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_NULL(tv)  do { \
-+		(tv)->t = DUK_TAG_NULL; \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_BOOLEAN(tv,val)  do { \
-+		(tv)->t = DUK_TAG_BOOLEAN; \
-+		(tv)->v.i = (val); \
-+	} while (0)
-+
-+#if defined(DUK_USE_FASTINT)
-+#define DUK_TVAL_SET_DOUBLE(tv,val)  do { \
-+		(tv)->t = DUK__TAG_NUMBER; \
-+		(tv)->v.d = (val); \
-+	} while (0)
-+#define DUK_TVAL_SET_FASTINT(tv,val)  do { \
-+		(tv)->t = DUK_TAG_FASTINT; \
-+		(tv)->v.fi = (val); \
-+	} while (0)
-+#define DUK_TVAL_SET_FASTINT_U32(tv,val)  do { \
-+		(tv)->t = DUK_TAG_FASTINT; \
-+		(tv)->v.fi = (duk_int64_t) (val); \
-+	} while (0)
-+#define DUK_TVAL_SET_FASTINT_I32(tv,val)  do { \
-+		(tv)->t = DUK_TAG_FASTINT; \
-+		(tv)->v.fi = (duk_int64_t) (val); \
-+	} while (0)
-+#define DUK_TVAL_SET_NUMBER_CHKFAST(tv,d) \
-+	duk_tval_set_number_chkfast((tv), (d))
-+#define DUK_TVAL_SET_NUMBER(tv,val) \
-+	DUK_TVAL_SET_DOUBLE((tv), (val))
-+#define DUK_TVAL_CHKFAST_INPLACE(v)  do { \
-+		duk_tval *duk__tv; \
-+		duk_double_t duk__d; \
-+		duk__tv = (v); \
-+		if (DUK_TVAL_IS_DOUBLE(duk__tv)) { \
-+			duk__d = DUK_TVAL_GET_DOUBLE(duk__tv); \
-+			DUK_TVAL_SET_NUMBER_CHKFAST(duk__tv, duk__d); \
-+		} \
-+	} while (0)
-+#else
-+#define DUK_TVAL_SET_NUMBER(tv,val)  do { \
-+		(tv)->t = DUK__TAG_NUMBER; \
-+		(tv)->v.d = (val); \
-+	} while (0)
-+#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d) \
-+	DUK_TVAL_SET_NUMBER((tv), (d))
-+#define DUK_TVAL_SET_DOUBLE(v,d) \
-+	DUK_TVAL_SET_NUMBER((tv), (d))
-+#define DUK_TVAL_CHKFAST_INPLACE(v)  do { } while (0)
-+#endif  /* DUK_USE_FASTINT */
-+
-+#define DUK_TVAL_SET_POINTER(tv,hptr)  do { \
-+		(tv)->t = DUK_TAG_POINTER; \
-+		(tv)->v.voidptr = (hptr); \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_LIGHTFUNC(tv,fp,flags)  do { \
-+		(tv)->t = DUK_TAG_LIGHTFUNC; \
-+		(tv)->v_extra = (flags); \
-+		(tv)->v.lightfunc = (duk_c_function) (fp); \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_STRING(tv,hptr)  do { \
-+		(tv)->t = DUK_TAG_STRING; \
-+		(tv)->v.hstring = (hptr); \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_OBJECT(tv,hptr)  do { \
-+		(tv)->t = DUK_TAG_OBJECT; \
-+		(tv)->v.hobject = (hptr); \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_BUFFER(tv,hptr)  do { \
-+		(tv)->t = DUK_TAG_BUFFER; \
-+		(tv)->v.hbuffer = (hptr); \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_NAN(tv)  do { \
-+		/* in non-packed representation we don't care about which NaN is used */ \
-+		(tv)->t = DUK__TAG_NUMBER; \
-+		(tv)->v.d = DUK_DOUBLE_NAN; \
-+	} while (0)
-+
-+#define DUK_TVAL_SET_TVAL(v,x)             do { *(v) = *(x); } while (0)
-+
-+/* getters */
-+#define DUK_TVAL_GET_BOOLEAN(tv)           ((tv)->v.i)
-+#if defined(DUK_USE_FASTINT)
-+#define DUK_TVAL_GET_DOUBLE(tv)            ((tv)->v.d)
-+#define DUK_TVAL_GET_FASTINT(tv)           ((tv)->v.fi)
-+#define DUK_TVAL_GET_FASTINT_U32(tv)       ((duk_uint32_t) ((tv)->v.fi))
-+#define DUK_TVAL_GET_FASTINT_I32(tv)       ((duk_int32_t) ((tv)->v.fi))
-+#if 0
-+#define DUK_TVAL_GET_NUMBER(tv)            (DUK_TVAL_IS_FASTINT((tv)) ? \
-+                                               (duk_double_t) DUK_TVAL_GET_FASTINT((tv)) : \
-+                                               DUK_TVAL_GET_DOUBLE((tv)))
-+#define DUK_TVAL_GET_NUMBER(tv)            duk_tval_get_number_unpacked((tv))
-+#else
-+/* This seems reasonable overall. */
-+#define DUK_TVAL_GET_NUMBER(tv)            (DUK_TVAL_IS_FASTINT((tv)) ? \
-+                                               duk_tval_get_number_unpacked_fastint((tv)) : \
-+                                               DUK_TVAL_GET_DOUBLE((tv)))
-+#endif
-+#else
-+#define DUK_TVAL_GET_NUMBER(tv)            ((tv)->v.d)
-+#define DUK_TVAL_GET_DOUBLE(tv)            ((tv)->v.d)
-+#endif  /* DUK_USE_FASTINT */
-+#define DUK_TVAL_GET_POINTER(tv)           ((tv)->v.voidptr)
-+#define DUK_TVAL_GET_LIGHTFUNC(tv,out_fp,out_flags)  do { \
-+		(out_flags) = (duk_uint32_t) (tv)->v_extra; \
-+		(out_fp) = (tv)->v.lightfunc; \
-+	} while (0)
-+#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv) ((tv)->v.lightfunc)
-+#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv)   ((duk_uint32_t) ((tv)->v_extra))
-+#define DUK_TVAL_GET_STRING(tv)            ((tv)->v.hstring)
-+#define DUK_TVAL_GET_OBJECT(tv)            ((tv)->v.hobject)
-+#define DUK_TVAL_GET_BUFFER(tv)            ((tv)->v.hbuffer)
-+#define DUK_TVAL_GET_HEAPHDR(tv)           ((tv)->v.heaphdr)
-+
-+/* decoding */
-+#define DUK_TVAL_GET_TAG(tv)               ((tv)->t)
-+#define DUK_TVAL_IS_UNDEFINED(tv)          ((tv)->t == DUK_TAG_UNDEFINED)
-+#define DUK_TVAL_IS_UNDEFINED_ACTUAL(tv)   (((tv)->t == DUK_TAG_UNDEFINED) && ((tv)->v.i == 0))
-+#define DUK_TVAL_IS_UNDEFINED_UNUSED(tv)   (((tv)->t == DUK_TAG_UNDEFINED) && ((tv)->v.i != 0))
-+#define DUK_TVAL_IS_NULL(tv)               ((tv)->t == DUK_TAG_NULL)
-+#define DUK_TVAL_IS_BOOLEAN(tv)            ((tv)->t == DUK_TAG_BOOLEAN)
-+#define DUK_TVAL_IS_BOOLEAN_TRUE(tv)       (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i != 0))
-+#define DUK_TVAL_IS_BOOLEAN_FALSE(tv)      (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i == 0))
-+#if defined(DUK_USE_FASTINT)
-+#define DUK_TVAL_IS_DOUBLE(tv)             ((tv)->t == DUK__TAG_NUMBER)
-+#define DUK_TVAL_IS_FASTINT(tv)            ((tv)->t == DUK_TAG_FASTINT)
-+#define DUK_TVAL_IS_NUMBER(tv)             ((tv)->t == DUK__TAG_NUMBER || \
-+                                            (tv)->t == DUK_TAG_FASTINT)
-+#else
-+#define DUK_TVAL_IS_NUMBER(tv)             ((tv)->t == DUK__TAG_NUMBER)
-+#define DUK_TVAL_IS_DOUBLE(v)              DUK_TVAL_IS_NUMBER((v))
-+#endif  /* DUK_USE_FASTINT */
-+#define DUK_TVAL_IS_POINTER(tv)            ((tv)->t == DUK_TAG_POINTER)
-+#define DUK_TVAL_IS_LIGHTFUNC(tv)          ((tv)->t == DUK_TAG_LIGHTFUNC)
-+#define DUK_TVAL_IS_STRING(tv)             ((tv)->t == DUK_TAG_STRING)
-+#define DUK_TVAL_IS_OBJECT(tv)             ((tv)->t == DUK_TAG_OBJECT)
-+#define DUK_TVAL_IS_BUFFER(tv)             ((tv)->t == DUK_TAG_BUFFER)
-+
-+#define DUK_TVAL_IS_HEAP_ALLOCATED(tv)     ((tv)->t >= DUK_TAG_STRING)
-+
-+#if defined(DUK_USE_FASTINT)
-+/* Inlining is only effective in a single file build. */
-+#if 0
-+DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked(duk_tval *tv);
-+#endif
-+DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked_fastint(duk_tval *tv);
-+#endif
-+
-+#endif  /* DUK_USE_PACKED_TVAL */
-+
-+/*
-+ *  Convenience (independent of representation)
-+ */
-+
-+#define DUK_TVAL_SET_BOOLEAN_TRUE(v)        DUK_TVAL_SET_BOOLEAN(v, 1)
-+#define DUK_TVAL_SET_BOOLEAN_FALSE(v)       DUK_TVAL_SET_BOOLEAN(v, 0)
-+
-+/* Lightfunc flags packing and unpacking. */
-+/* Sign extend: 0x0000##00 -> 0x##000000 -> sign extend to 0xssssss## */
-+#define DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags) \
-+	((((duk_int32_t) (lf_flags)) << 16) >> 24)
-+#define DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags) \
-+	(((lf_flags) >> 4) & 0x0f)
-+#define DUK_LFUNC_FLAGS_GET_NARGS(lf_flags) \
-+	((lf_flags) & 0x0f)
-+#define DUK_LFUNC_FLAGS_PACK(magic,length,nargs) \
-+	(((magic) & 0xff) << 8) | ((length) << 4) | (nargs)
-+
-+#define DUK_LFUNC_NARGS_VARARGS             0x0f   /* varargs marker */
-+#define DUK_LFUNC_NARGS_MIN                 0x00
-+#define DUK_LFUNC_NARGS_MAX                 0x0e   /* max, excl. varargs marker */
-+#define DUK_LFUNC_LENGTH_MIN                0x00
-+#define DUK_LFUNC_LENGTH_MAX                0x0f
-+#define DUK_LFUNC_MAGIC_MIN                 (-0x80)
-+#define DUK_LFUNC_MAGIC_MAX                 0x7f
-+
-+/* fastint constants etc */
-+#if defined(DUK_USE_FASTINT)
-+#define DUK_FASTINT_MIN           (-0x800000000000LL)
-+#define DUK_FASTINT_MAX           0x7fffffffffffLL
-+#define DUK_FASTINT_BITS          48
-+
-+DUK_INTERNAL_DECL void duk_tval_set_number_chkfast(duk_tval *tv, duk_double_t x);
-+#endif
-+
-+#endif  /* DUK_TVAL_H_INCLUDED */
-+#line 1 "duk_heaphdr.h"
-+/*
-+ *  Heap header definition and assorted macros, including ref counting.
-+ *  Access all fields through the accessor macros.
-+ */
-+
-+#ifndef DUK_HEAPHDR_H_INCLUDED
-+#define DUK_HEAPHDR_H_INCLUDED
-+
-+/*
-+ *  Common heap header
-+ *
-+ *  All heap objects share the same flags and refcount fields.  Objects other
-+ *  than strings also need to have a single or double linked list pointers
-+ *  for insertion into the "heap allocated" list.  Strings are held in the
-+ *  heap-wide string table so they don't need link pointers.
-+ *
-+ *  Technically, 'h_refcount' must be wide enough to guarantee that it cannot
-+ *  wrap (otherwise objects might be freed incorrectly after wrapping).  This
-+ *  means essentially that the refcount field must be as wide as data pointers.
-+ *  On 64-bit platforms this means that the refcount needs to be 64 bits even
-+ *  if an 'int' is 32 bits.  This is a bit unfortunate, and compromising on
-+ *  this might be reasonable in the future.
-+ *
-+ *  Heap header size on 32-bit platforms: 8 bytes without reference counting,
-+ *  16 bytes with reference counting.
-+ */
-+
-+struct duk_heaphdr {
-+	duk_uint32_t h_flags;
-+
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+#if defined(DUK_USE_REFCOUNT16)
-+	duk_uint16_t h_refcount16;
-+#else
-+	duk_size_t h_refcount;
-+#endif
-+#endif
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t h_next16;
-+#else
-+	duk_heaphdr *h_next;
-+#endif
-+
-+#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
-+	/* refcounting requires direct heap frees, which in turn requires a dual linked heap */
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t h_prev16;
-+#else
-+	duk_heaphdr *h_prev;
-+#endif
-+#endif
-+
-+	/* When DUK_USE_HEAPPTR16 (and DUK_USE_REFCOUNT16) is in use, the
-+	 * struct won't align nicely to 4 bytes.  This 16-bit extra field
-+	 * is added to make the alignment clean; the field can be used by
-+	 * heap objects when 16-bit packing is used.  This field is now
-+	 * conditional to DUK_USE_HEAPPTR16 only, but it is intended to be
-+	 * used with DUK_USE_REFCOUNT16 and DUK_USE_DOUBLE_LINKED_HEAP;
-+	 * this only matter to low memory environments anyway.
-+	 */
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t h_extra16;
-+#endif
-+};
-+
-+struct duk_heaphdr_string {
-+	/* 16 bits would be enough for shared heaphdr flags and duk_hstring
-+	 * flags.  The initial parts of duk_heaphdr_string and duk_heaphdr
-+	 * must match so changing the flags field size here would be quite
-+	 * awkward.  However, to minimize struct size, we can pack at least
-+	 * 16 bits of duk_hstring data into the flags field.
-+	 */
-+	duk_uint32_t h_flags;
-+
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+#if defined(DUK_USE_REFCOUNT16)
-+	duk_uint16_t h_refcount16;
-+#else
-+	duk_size_t h_refcount;
-+#endif
-+#endif
-+};
-+
-+#define DUK_HEAPHDR_FLAGS_TYPE_MASK      0x00000003UL
-+#define DUK_HEAPHDR_FLAGS_FLAG_MASK      (~DUK_HEAPHDR_FLAGS_TYPE_MASK)
-+
-+                                             /* 2 bits for heap type */
-+#define DUK_HEAPHDR_FLAGS_HEAP_START     2   /* 4 heap flags */
-+#define DUK_HEAPHDR_FLAGS_USER_START     6   /* 26 user flags */
-+
-+#define DUK_HEAPHDR_HEAP_FLAG_NUMBER(n)  (DUK_HEAPHDR_FLAGS_HEAP_START + (n))
-+#define DUK_HEAPHDR_USER_FLAG_NUMBER(n)  (DUK_HEAPHDR_FLAGS_USER_START + (n))
-+#define DUK_HEAPHDR_HEAP_FLAG(n)         (1UL << (DUK_HEAPHDR_FLAGS_HEAP_START + (n)))
-+#define DUK_HEAPHDR_USER_FLAG(n)         (1UL << (DUK_HEAPHDR_FLAGS_USER_START + (n)))
-+
-+#define DUK_HEAPHDR_FLAG_REACHABLE       DUK_HEAPHDR_HEAP_FLAG(0)  /* mark-and-sweep: reachable */
-+#define DUK_HEAPHDR_FLAG_TEMPROOT        DUK_HEAPHDR_HEAP_FLAG(1)  /* mark-and-sweep: children not processed */
-+#define DUK_HEAPHDR_FLAG_FINALIZABLE     DUK_HEAPHDR_HEAP_FLAG(2)  /* mark-and-sweep: finalizable (on current pass) */
-+#define DUK_HEAPHDR_FLAG_FINALIZED       DUK_HEAPHDR_HEAP_FLAG(3)  /* mark-and-sweep: finalized (on previous pass) */
-+
-+#define DUK_HTYPE_MIN                    1
-+#define DUK_HTYPE_STRING                 1
-+#define DUK_HTYPE_OBJECT                 2
-+#define DUK_HTYPE_BUFFER                 3
-+#define DUK_HTYPE_MAX                    3
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+#define DUK_HEAPHDR_GET_NEXT(heap,h) \
-+	((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_next16))
-+#define DUK_HEAPHDR_SET_NEXT(heap,h,val)   do { \
-+		(h)->h_next16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) val); \
-+	} while (0)
-+#else
-+#define DUK_HEAPHDR_GET_NEXT(heap,h)  ((h)->h_next)
-+#define DUK_HEAPHDR_SET_NEXT(heap,h,val)   do { \
-+		(h)->h_next = (val); \
-+	} while (0)
-+#endif
-+
-+#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
-+#if defined(DUK_USE_HEAPPTR16)
-+#define DUK_HEAPHDR_GET_PREV(heap,h) \
-+	((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_prev16))
-+#define DUK_HEAPHDR_SET_PREV(heap,h,val)   do { \
-+		(h)->h_prev16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (val)); \
-+	} while (0)
-+#else
-+#define DUK_HEAPHDR_GET_PREV(heap,h)       ((h)->h_prev)
-+#define DUK_HEAPHDR_SET_PREV(heap,h,val)   do { \
-+		(h)->h_prev = (val); \
-+	} while (0)
-+#endif
-+#endif
-+
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+#if defined(DUK_USE_REFCOUNT16)
-+#define DUK_HEAPHDR_GET_REFCOUNT(h)   ((h)->h_refcount16)
-+#define DUK_HEAPHDR_SET_REFCOUNT(h,val)  do { \
-+		(h)->h_refcount16 = (val); \
-+	} while (0)
-+#define DUK_HEAPHDR_PREINC_REFCOUNT(h)  (++(h)->h_refcount16)  /* result: updated refcount */
-+#define DUK_HEAPHDR_PREDEC_REFCOUNT(h)  (--(h)->h_refcount16)  /* result: updated refcount */
-+#else
-+#define DUK_HEAPHDR_GET_REFCOUNT(h)   ((h)->h_refcount)
-+#define DUK_HEAPHDR_SET_REFCOUNT(h,val)  do { \
-+		(h)->h_refcount = (val); \
-+	} while (0)
-+#define DUK_HEAPHDR_PREINC_REFCOUNT(h)  (++(h)->h_refcount)  /* result: updated refcount */
-+#define DUK_HEAPHDR_PREDEC_REFCOUNT(h)  (--(h)->h_refcount)  /* result: updated refcount */
-+#endif
-+#else
-+/* refcount macros not defined without refcounting, caller must #ifdef now */
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+
-+/*
-+ *  Note: type is treated as a field separate from flags, so some masking is
-+ *  involved in the macros below.
-+ */
-+
-+#define DUK_HEAPHDR_GET_FLAGS_RAW(h)  ((h)->h_flags)
-+
-+#define DUK_HEAPHDR_GET_FLAGS(h)      ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK)
-+#define DUK_HEAPHDR_SET_FLAGS(h,val)  do { \
-+		(h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) | (val); \
-+	} while (0)
-+
-+#define DUK_HEAPHDR_GET_TYPE(h)       ((h)->h_flags & DUK_HEAPHDR_FLAGS_TYPE_MASK)
-+#define DUK_HEAPHDR_SET_TYPE(h,val)   do { \
-+		(h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_TYPE_MASK)) | (val); \
-+	} while (0)
-+
-+#define DUK_HEAPHDR_HTYPE_VALID(h)    ( \
-+	DUK_HEAPHDR_GET_TYPE((h)) >= DUK_HTYPE_MIN && \
-+	DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \
-+	)
-+
-+#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h,tval,fval)  do { \
-+		(h)->h_flags = ((tval) & DUK_HEAPHDR_FLAGS_TYPE_MASK) | \
-+		               ((fval) & DUK_HEAPHDR_FLAGS_FLAG_MASK); \
-+	} while (0)
-+
-+#define DUK_HEAPHDR_SET_FLAG_BITS(h,bits)  do { \
-+		DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
-+		(h)->h_flags |= (bits); \
-+	} while (0)
-+
-+#define DUK_HEAPHDR_CLEAR_FLAG_BITS(h,bits)  do { \
-+		DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
-+		(h)->h_flags &= ~((bits)); \
-+	} while (0)
-+
-+#define DUK_HEAPHDR_CHECK_FLAG_BITS(h,bits)  (((h)->h_flags & (bits)) != 0)
-+
-+#define DUK_HEAPHDR_SET_REACHABLE(h)      DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
-+#define DUK_HEAPHDR_CLEAR_REACHABLE(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
-+#define DUK_HEAPHDR_HAS_REACHABLE(h)      DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
-+
-+#define DUK_HEAPHDR_SET_TEMPROOT(h)       DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
-+#define DUK_HEAPHDR_CLEAR_TEMPROOT(h)     DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
-+#define DUK_HEAPHDR_HAS_TEMPROOT(h)       DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
-+
-+#define DUK_HEAPHDR_SET_FINALIZABLE(h)    DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
-+#define DUK_HEAPHDR_CLEAR_FINALIZABLE(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
-+#define DUK_HEAPHDR_HAS_FINALIZABLE(h)    DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
-+
-+#define DUK_HEAPHDR_SET_FINALIZED(h)      DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
-+#define DUK_HEAPHDR_CLEAR_FINALIZED(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
-+#define DUK_HEAPHDR_HAS_FINALIZED(h)      DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
-+
-+/* get or set a range of flags; m=first bit number, n=number of bits */
-+#define DUK_HEAPHDR_GET_FLAG_RANGE(h,m,n)  (((h)->h_flags >> (m)) & ((1UL << (n)) - 1UL))
-+
-+#define DUK_HEAPHDR_SET_FLAG_RANGE(h,m,n,v)  do { \
-+		(h)->h_flags = \
-+			((h)->h_flags & (~(((1 << (n)) - 1) << (m)))) \
-+			| ((v) << (m)); \
-+	} while (0)
-+
-+/* init pointer fields to null */
-+#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
-+#define DUK_HEAPHDR_INIT_NULLS(h)       do { \
-+		DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
-+		DUK_HEAPHDR_SET_PREV((h), (void *) NULL); \
-+	} while (0)
-+#else
-+#define DUK_HEAPHDR_INIT_NULLS(h)       do { \
-+		DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
-+	} while (0)
-+#endif
-+
-+#define DUK_HEAPHDR_STRING_INIT_NULLS(h)  /* currently nop */
-+
-+/*
-+ *  Reference counting helper macros.  The macros take a thread argument
-+ *  and must thus always be executed in a specific thread context.  The
-+ *  thread argument is needed for features like finalization.  Currently
-+ *  it is not required for INCREF, but it is included just in case.
-+ *
-+ *  Note that 'raw' macros such as DUK_HEAPHDR_GET_REFCOUNT() are not
-+ *  defined without DUK_USE_REFERENCE_COUNTING, so caller must #ifdef
-+ *  around them.
-+ */
-+
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+
-+/* Fast variants, inline refcount operations except for refzero handling.
-+ * Can be used explicitly when speed is always more important than size.
-+ * For a good compiler and a single file build, these are basically the
-+ * same as a forced inline.
-+ */
-+#define DUK_TVAL_INCREF_FAST(thr,tv) do { \
-+		duk_tval *duk__tv = (tv); \
-+		DUK_ASSERT(duk__tv != NULL); \
-+		if (DUK_TVAL_IS_HEAP_ALLOCATED(duk__tv)) { \
-+			duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
-+			DUK_ASSERT(duk__h != NULL); \
-+			DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
-+			DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
-+		} \
-+	} while (0)
-+#define DUK_TVAL_DECREF_FAST(thr,tv) do { \
-+		duk_tval *duk__tv = (tv); \
-+		DUK_ASSERT(duk__tv != NULL); \
-+		if (DUK_TVAL_IS_HEAP_ALLOCATED(duk__tv)) { \
-+			duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
-+			DUK_ASSERT(duk__h != NULL); \
-+			DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
-+			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
-+			if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
-+				duk_heaphdr_refzero((thr), duk__h); \
-+			} \
-+		} \
-+	} while (0)
-+#define DUK_HEAPHDR_INCREF_FAST(thr,h) do { \
-+		duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
-+		DUK_ASSERT(duk__h != NULL); \
-+		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
-+		DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
-+	} while (0)
-+#define DUK_HEAPHDR_DECREF_FAST(thr,h) do { \
-+		duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
-+		DUK_ASSERT(duk__h != NULL); \
-+		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
-+		DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
-+		if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
-+			duk_heaphdr_refzero((thr), duk__h); \
-+		} \
-+	} while (0)
-+
-+/* Slow variants, call to a helper to reduce code size.
-+ * Can be used explicitly when size is always more important than speed.
-+ */
-+#define DUK_TVAL_INCREF_SLOW(thr,tv) do { \
-+		duk_tval_incref((tv)); \
-+	} while (0)
-+#define DUK_TVAL_DECREF_SLOW(thr,tv) do { \
-+		duk_tval_decref((thr), (tv)); \
-+	} while (0)
-+#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do { \
-+		duk_heaphdr_incref((duk_heaphdr *) (h)); \
-+	} while (0)
-+#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do { \
-+		duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
-+	} while (0)
-+
-+/* Default variants.  Selection depends on speed/size preference.
-+ * Concretely: with gcc 4.8.1 -Os x64 the difference in final binary
-+ * is about +1kB for _FAST variants.
-+ */
-+#if defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
-+#define DUK_TVAL_INCREF(thr,tv)                DUK_TVAL_INCREF_FAST((thr),(tv))
-+#define DUK_TVAL_DECREF(thr,tv)                DUK_TVAL_DECREF_FAST((thr),(tv))
-+#define DUK_HEAPHDR_INCREF(thr,h)              DUK_HEAPHDR_INCREF_FAST((thr),(h))
-+#define DUK_HEAPHDR_DECREF(thr,h)              DUK_HEAPHDR_DECREF_FAST((thr),(h))
-+#else
-+#define DUK_TVAL_INCREF(thr,tv)                DUK_TVAL_INCREF_SLOW((thr),(tv))
-+#define DUK_TVAL_DECREF(thr,tv)                DUK_TVAL_DECREF_SLOW((thr),(tv))
-+#define DUK_HEAPHDR_INCREF(thr,h)              DUK_HEAPHDR_INCREF_SLOW((thr),(h))
-+#define DUK_HEAPHDR_DECREF(thr,h)              DUK_HEAPHDR_DECREF_SLOW((thr),(h))
-+#endif
-+
-+/* Casting convenience. */
-+#define DUK_HSTRING_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-+#define DUK_HSTRING_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
-+#define DUK_HOBJECT_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-+#define DUK_HOBJECT_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
-+#define DUK_HBUFFER_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-+#define DUK_HBUFFER_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
-+#define DUK_HCOMPILEDFUNCTION_INCREF(thr,h)    DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-+#define DUK_HCOMPILEDFUNCTION_DECREF(thr,h)    DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
-+#define DUK_HNATIVEFUNCTION_INCREF(thr,h)      DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-+#define DUK_HNATIVEFUNCTION_DECREF(thr,h)      DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
-+#define DUK_HTHREAD_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-+#define DUK_HTHREAD_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
-+
-+/* Convenience for some situations; the above macros don't allow NULLs
-+ * for performance reasons.
-+ */
-+#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do { \
-+		if ((h) != NULL) { \
-+			DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \
-+		} \
-+	} while (0)
-+#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do { \
-+		if ((h) != NULL) { \
-+			DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \
-+		} \
-+	} while (0)
-+
-+#else  /* DUK_USE_REFERENCE_COUNTING */
-+
-+#define DUK_TVAL_INCREF_FAST(thr,v)            do {} while (0) /* nop */
-+#define DUK_TVAL_DECREF_FAST(thr,v)            do {} while (0) /* nop */
-+#define DUK_TVAL_INCREF_SLOW(thr,v)            do {} while (0) /* nop */
-+#define DUK_TVAL_DECREF_SLOW(thr,v)            do {} while (0) /* nop */
-+#define DUK_TVAL_INCREF(thr,v)                 do {} while (0) /* nop */
-+#define DUK_TVAL_DECREF(thr,v)                 do {} while (0) /* nop */
-+#define DUK_HEAPHDR_INCREF_FAST(thr,h)         do {} while (0) /* nop */
-+#define DUK_HEAPHDR_DECREF_FAST(thr,h)         do {} while (0) /* nop */
-+#define DUK_HEAPHDR_INCREF_SLOW(thr,h)         do {} while (0) /* nop */
-+#define DUK_HEAPHDR_DECREF_SLOW(thr,h)         do {} while (0) /* nop */
-+#define DUK_HEAPHDR_INCREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HEAPHDR_DECREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HSTRING_INCREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HSTRING_DECREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HOBJECT_INCREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HOBJECT_DECREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HBUFFER_INCREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HBUFFER_DECREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HCOMPILEDFUNCTION_INCREF(thr,h)    do {} while (0) /* nop */
-+#define DUK_HCOMPILEDFUNCTION_DECREF(thr,h)    do {} while (0) /* nop */
-+#define DUK_HNATIVEFUNCTION_INCREF(thr,h)      do {} while (0) /* nop */
-+#define DUK_HNATIVEFUNCTION_DECREF(thr,h)      do {} while (0) /* nop */
-+#define DUK_HTHREAD_INCREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HTHREAD_DECREF(thr,h)              do {} while (0) /* nop */
-+#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h)    do {} while (0) /* nop */
-+#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h)    do {} while (0) /* nop */
-+
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+
-+#endif  /* DUK_HEAPHDR_H_INCLUDED */
-+#line 1 "duk_api_internal.h"
-+/*
-+ *  Internal API calls which have (stack and other) semantics similar
-+ *  to the public API.
-+ */
-+
-+#ifndef DUK_API_INTERNAL_H_INCLUDED
-+#define DUK_API_INTERNAL_H_INCLUDED
-+
-+/* duk_push_sprintf constants */
-+#define DUK_PUSH_SPRINTF_INITIAL_SIZE  256L
-+#define DUK_PUSH_SPRINTF_SANITY_LIMIT  (1L * 1024L * 1024L * 1024L)
-+
-+/* Flag ORed to err_code to indicate __FILE__ / __LINE__ is not
-+ * blamed as source of error for error fileName / lineNumber.
-+ */
-+#define DUK_ERRCODE_FLAG_NOBLAME_FILELINE  (1L << 24)
-+
-+/* Valstack resize flags */
-+#define DUK_VSRESIZE_FLAG_SHRINK           (1 << 0)
-+#define DUK_VSRESIZE_FLAG_COMPACT          (1 << 1)
-+#define DUK_VSRESIZE_FLAG_THROW            (1 << 2)
-+
-+/* Current convention is to use duk_size_t for value stack sizes and global indices,
-+ * and duk_idx_t for local frame indices.
-+ */
-+DUK_INTERNAL_DECL
-+duk_bool_t duk_valstack_resize_raw(duk_context *ctx,
-+                                   duk_size_t min_new_size,
-+                                   duk_small_uint_t flags);
-+
-+DUK_INTERNAL_DECL duk_tval *duk_get_tval(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_tval *duk_require_tval(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL void duk_push_tval(duk_context *ctx, duk_tval *tv);
-+
-+/* Push the current 'this' binding; throw TypeError if binding is not object
-+ * coercible (CheckObjectCoercible).
-+ */
-+DUK_INTERNAL_DECL void duk_push_this_check_object_coercible(duk_context *ctx);
-+
-+/* duk_push_this() + CheckObjectCoercible() + duk_to_object() */
-+DUK_INTERNAL_DECL duk_hobject *duk_push_this_coercible_to_object(duk_context *ctx);
-+
-+/* duk_push_this() + CheckObjectCoercible() + duk_to_string() */
-+DUK_INTERNAL_DECL duk_hstring *duk_push_this_coercible_to_string(duk_context *ctx);
-+
-+/* duk_push_(u)int() is guaranteed to support at least (un)signed 32-bit range */
-+#define duk_push_u32(ctx,val) \
-+	duk_push_uint((ctx), (duk_uint_t) (val))
-+#define duk_push_i32(ctx,val) \
-+	duk_push_int((ctx), (duk_int_t) (val))
-+
-+/* sometimes stack and array indices need to go on the stack */
-+#define duk_push_idx(ctx,val) \
-+	duk_push_int((ctx), (duk_int_t) (val))
-+#define duk_push_uarridx(ctx,val) \
-+	duk_push_uint((ctx), (duk_uint_t) (val))
-+#define duk_push_size_t(ctx,val) \
-+	duk_push_uint((ctx), (duk_uint_t) (val))  /* XXX: assumed to fit for now */
-+
-+/* internal helper for looking up a tagged type */
-+#define  DUK_GETTAGGED_FLAG_ALLOW_NULL  (1L << 24)
-+#define  DUK_GETTAGGED_FLAG_CHECK_CLASS (1L << 25)
-+#define  DUK_GETTAGGED_CLASS_SHIFT      16
-+
-+DUK_INTERNAL_DECL duk_heaphdr *duk_get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t flags_and_tag);
-+
-+DUK_INTERNAL_DECL duk_hstring *duk_get_hstring(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hobject *duk_get_hobject(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hbuffer *duk_get_hbuffer(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hthread *duk_get_hthread(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hcompiledfunction *duk_get_hcompiledfunction(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hnativefunction *duk_get_hnativefunction(duk_context *ctx, duk_idx_t index);
-+
-+#define duk_get_hobject_with_class(ctx,index,classnum) \
-+	((duk_hobject *) duk_get_tagged_heaphdr_raw((ctx), (index), \
-+		DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL | \
-+		DUK_GETTAGGED_FLAG_CHECK_CLASS | ((classnum) << DUK_GETTAGGED_CLASS_SHIFT)))
-+
-+#if 0  /* This would be pointless: unexpected type and lightfunc would both return NULL */
-+DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_or_lfunc(duk_context *ctx, duk_idx_t index);
-+#endif
-+DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index);
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL void *duk_get_voidptr(duk_context *ctx, duk_idx_t index);
-+#endif
-+
-+DUK_INTERNAL_DECL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped);  /* out_clamped=NULL, RangeError if outside range */
-+DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval);
-+DUK_INTERNAL_DECL duk_int_t duk_to_int_check_range(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval);
-+
-+DUK_INTERNAL_DECL duk_hstring *duk_require_hstring(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hobject *duk_require_hobject(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hbuffer *duk_require_hbuffer(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hthread *duk_require_hthread(duk_context *ctx, duk_idx_t index);
-+#if 0  /*unused */
-+DUK_INTERNAL_DECL duk_hcompiledfunction *duk_require_hcompiledfunction(duk_context *ctx, duk_idx_t index);
-+#endif
-+DUK_INTERNAL_DECL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index);
-+
-+#define duk_require_hobject_with_class(ctx,index,classnum) \
-+	((duk_hobject *) duk_get_tagged_heaphdr_raw((ctx), (index), \
-+		DUK_TAG_OBJECT | \
-+		DUK_GETTAGGED_FLAG_CHECK_CLASS | ((classnum) << DUK_GETTAGGED_CLASS_SHIFT)))
-+
-+DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx_t index);
-+DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index);
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+DUK_INTERNAL_DECL void duk_push_unused(duk_context *ctx);
-+#endif
-+DUK_INTERNAL_DECL void duk_push_hstring(duk_context *ctx, duk_hstring *h);
-+DUK_INTERNAL_DECL void duk_push_hstring_stridx(duk_context *ctx, duk_small_int_t stridx);
-+DUK_INTERNAL_DECL void duk_push_hobject(duk_context *ctx, duk_hobject *h);
-+DUK_INTERNAL_DECL void duk_push_hbuffer(duk_context *ctx, duk_hbuffer *h);
-+#define duk_push_hthread(ctx,h) \
-+	duk_push_hobject((ctx), (duk_hobject *) (h))
-+#define duk_push_hcompiledfunction(ctx,h) \
-+	duk_push_hobject((ctx), (duk_hobject *) (h))
-+#define duk_push_hnativefunction(ctx,h) \
-+	duk_push_hobject((ctx), (duk_hobject *) (h))
-+DUK_INTERNAL_DECL void duk_push_hobject_bidx(duk_context *ctx, duk_small_int_t builtin_idx);
-+DUK_INTERNAL_DECL duk_idx_t duk_push_object_helper(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx);
-+DUK_INTERNAL_DECL duk_idx_t duk_push_object_helper_proto(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_hobject *proto);
-+DUK_INTERNAL_DECL duk_idx_t duk_push_object_internal(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_idx_t duk_push_compiledfunction(duk_context *ctx);
-+DUK_INTERNAL_DECL void duk_push_c_function_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs);
-+DUK_INTERNAL_DECL void duk_push_c_function_noconstruct_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs);
-+
-+DUK_INTERNAL_DECL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz);
-+DUK_INTERNAL_DECL void duk_push_lightfunc_name(duk_context *ctx, duk_tval *tv);
-+DUK_INTERNAL_DECL void duk_push_lightfunc_tostring(duk_context *ctx, duk_tval *tv);
-+
-+DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx);     /* [] -> [val] */
-+DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx);     /* [val] -> [] */
-+DUK_INTERNAL_DECL duk_bool_t duk_del_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx);     /* [] -> [] */
-+DUK_INTERNAL_DECL duk_bool_t duk_has_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx);     /* [] -> [] */
-+
-+DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx_boolean(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_bool_t *out_has_prop);  /* [] -> [] */
-+
-+DUK_INTERNAL_DECL void duk_xdef_prop(duk_context *ctx, duk_idx_t obj_index, duk_small_uint_t desc_flags);  /* [key val] -> [] */
-+DUK_INTERNAL_DECL void duk_xdef_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index, duk_small_uint_t desc_flags);  /* [val] -> [] */
-+DUK_INTERNAL_DECL void duk_xdef_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags);  /* [val] -> [] */
-+DUK_INTERNAL_DECL void duk_xdef_prop_stridx_builtin(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_int_t builtin_idx, duk_small_uint_t desc_flags);  /* [] -> [] */
-+DUK_INTERNAL_DECL void duk_xdef_prop_stridx_thrower(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags);  /* [] -> [] */
-+
-+/* These are macros for now, but could be separate functions to reduce code
-+ * footprint (check call site count before refactoring).
-+ */
-+#define duk_xdef_prop_wec(ctx,obj_index) \
-+	duk_xdef_prop((ctx), (obj_index), DUK_PROPDESC_FLAGS_WEC)
-+#define duk_xdef_prop_index_wec(ctx,obj_index,arr_index) \
-+	duk_xdef_prop_index((ctx), (obj_index), (arr_index), DUK_PROPDESC_FLAGS_WEC)
-+#define duk_xdef_prop_stridx_wec(ctx,obj_index,stridx) \
-+	duk_xdef_prop_stridx((ctx), (obj_index), (stridx), DUK_PROPDESC_FLAGS_WEC)
-+
-+/* Set object 'length'. */
-+DUK_INTERNAL_DECL void duk_set_length(duk_context *ctx, duk_idx_t index, duk_size_t length);
-+
-+#endif  /* DUK_API_INTERNAL_H_INCLUDED */
-+#line 1 "duk_hstring.h"
-+/*
-+ *  Heap string representation.
-+ *
-+ *  Strings are byte sequences ordinarily stored in extended UTF-8 format,
-+ *  allowing values larger than the official UTF-8 range (used internally)
-+ *  and also allowing UTF-8 encoding of surrogate pairs (CESU-8 format).
-+ *  Strings may also be invalid UTF-8 altogether which is the case e.g. with
-+ *  strings used as internal property names and raw buffers converted to
-+ *  strings.  In such cases the 'clen' field contains an inaccurate value.
-+ *
-+ *  Ecmascript requires support for 32-bit long strings.  However, since each
-+ *  16-bit codepoint can take 3 bytes in CESU-8, this representation can only
-+ *  support about 1.4G codepoint long strings in extreme cases.  This is not
-+ *  really a practical issue.
-+ */
-+
-+#ifndef DUK_HSTRING_H_INCLUDED
-+#define DUK_HSTRING_H_INCLUDED
-+
-+/* Impose a maximum string length for now.  Restricted artificially to
-+ * ensure adding a heap header length won't overflow size_t.  The limit
-+ * should be synchronized with DUK_HBUFFER_MAX_BYTELEN.
-+ *
-+ * E5.1 makes provisions to support strings longer than 4G characters.
-+ * This limit should be eliminated on 64-bit platforms (and increased
-+ * closer to maximum support on 32-bit platforms).
-+ */
-+
-+#if defined(DUK_USE_STRLEN16)
-+#define DUK_HSTRING_MAX_BYTELEN                     (0x0000ffffUL)
-+#else
-+#define DUK_HSTRING_MAX_BYTELEN                     (0x7fffffffUL)
-+#endif
-+
-+/* XXX: could add flags for "is valid CESU-8" (Ecmascript compatible strings),
-+ * "is valid UTF-8", "is valid extended UTF-8" (internal strings are not,
-+ * regexp bytecode is), and "contains non-BMP characters".  These are not
-+ * needed right now.
-+ */
-+
-+#define DUK_HSTRING_FLAG_ARRIDX                     DUK_HEAPHDR_USER_FLAG(0)  /* string is a valid array index */
-+#define DUK_HSTRING_FLAG_INTERNAL                   DUK_HEAPHDR_USER_FLAG(1)  /* string is internal */
-+#define DUK_HSTRING_FLAG_RESERVED_WORD              DUK_HEAPHDR_USER_FLAG(2)  /* string is a reserved word (non-strict) */
-+#define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD       DUK_HEAPHDR_USER_FLAG(3)  /* string is a reserved word (strict) */
-+#define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS          DUK_HEAPHDR_USER_FLAG(4)  /* string is 'eval' or 'arguments' */
-+#define DUK_HSTRING_FLAG_EXTDATA                    DUK_HEAPHDR_USER_FLAG(5)  /* string data is external (duk_hstring_external) */
-+
-+#define DUK_HSTRING_HAS_ARRIDX(x)                   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
-+#define DUK_HSTRING_HAS_INTERNAL(x)                 DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)
-+#define DUK_HSTRING_HAS_RESERVED_WORD(x)            DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
-+#define DUK_HSTRING_HAS_STRICT_RESERVED_WORD(x)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
-+#define DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(x)        DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
-+#define DUK_HSTRING_HAS_EXTDATA(x)                  DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
-+
-+#define DUK_HSTRING_SET_ARRIDX(x)                   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
-+#define DUK_HSTRING_SET_INTERNAL(x)                 DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)
-+#define DUK_HSTRING_SET_RESERVED_WORD(x)            DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
-+#define DUK_HSTRING_SET_STRICT_RESERVED_WORD(x)     DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
-+#define DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(x)        DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
-+#define DUK_HSTRING_SET_EXTDATA(x)                  DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
-+
-+#define DUK_HSTRING_CLEAR_ARRIDX(x)                 DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
-+#define DUK_HSTRING_CLEAR_INTERNAL(x)               DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)
-+#define DUK_HSTRING_CLEAR_RESERVED_WORD(x)          DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
-+#define DUK_HSTRING_CLEAR_STRICT_RESERVED_WORD(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
-+#define DUK_HSTRING_CLEAR_EVAL_OR_ARGUMENTS(x)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
-+#define DUK_HSTRING_CLEAR_EXTDATA(x)                DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
-+
-+#define DUK_HSTRING_IS_ASCII(x)                     (DUK_HSTRING_GET_BYTELEN((x)) == DUK_HSTRING_GET_CHARLEN((x)))
-+#define DUK_HSTRING_IS_EMPTY(x)                     (DUK_HSTRING_GET_BYTELEN((x)) == 0)
-+
-+#if defined(DUK_USE_STRHASH16)
-+#define DUK_HSTRING_GET_HASH(x)                     ((x)->hdr.h_flags >> 16)
-+#define DUK_HSTRING_SET_HASH(x,v) do { \
-+		(x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | ((v) << 16); \
-+	} while (0)
-+#else
-+#define DUK_HSTRING_GET_HASH(x)                     ((x)->hash)
-+#define DUK_HSTRING_SET_HASH(x,v) do { \
-+		(x)->hash = (v); \
-+	} while (0)
-+#endif
-+
-+#if defined(DUK_USE_STRLEN16)
-+#define DUK_HSTRING_GET_BYTELEN(x)                  ((x)->blen16)
-+#define DUK_HSTRING_SET_BYTELEN(x,v) do { \
-+		(x)->blen16 = (v); \
-+	} while (0)
-+#define DUK_HSTRING_GET_CHARLEN(x)                  ((x)->clen16)
-+#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
-+		(x)->clen16 = (v); \
-+	} while (0)
-+#else
-+#define DUK_HSTRING_GET_BYTELEN(x)                  ((x)->blen)
-+#define DUK_HSTRING_SET_BYTELEN(x,v) do { \
-+		(x)->blen = (v); \
-+	} while (0)
-+#define DUK_HSTRING_GET_CHARLEN(x)                  ((x)->clen)
-+#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
-+		(x)->clen = (v); \
-+	} while (0)
-+#endif
-+
-+#if defined(DUK_USE_HSTRING_EXTDATA)
-+#define DUK_HSTRING_GET_EXTDATA(x) \
-+	((x)->extdata)
-+#define DUK_HSTRING_GET_DATA(x) \
-+	(DUK_HSTRING_HAS_EXTDATA((x)) ? \
-+		DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) (x)) : ((const duk_uint8_t *) ((x) + 1)))
-+#else
-+#define DUK_HSTRING_GET_DATA(x) \
-+	((const duk_uint8_t *) ((x) + 1))
-+#endif
-+
-+#define DUK_HSTRING_GET_DATA_END(x) \
-+	(DUK_HSTRING_GET_DATA((x)) + (x)->blen)
-+
-+/* marker value; in E5 2^32-1 is not a valid array index (2^32-2 is highest valid) */
-+#define DUK_HSTRING_NO_ARRAY_INDEX  (0xffffffffUL)
-+
-+/* get array index related to string (or return DUK_HSTRING_NO_ARRAY_INDEX);
-+ * avoids helper call if string has no array index value.
-+ */
-+#define DUK_HSTRING_GET_ARRIDX_FAST(h)  \
-+	(DUK_HSTRING_HAS_ARRIDX((h)) ? duk_js_to_arrayindex_string_helper((h)) : DUK_HSTRING_NO_ARRAY_INDEX)
-+
-+/* slower but more compact variant */
-+#define DUK_HSTRING_GET_ARRIDX_SLOW(h)  \
-+	(duk_js_to_arrayindex_string_helper((h)))
-+
-+/*
-+ *  Misc
-+ */
-+
-+struct duk_hstring {
-+	/* Smaller heaphdr than for other objects, because strings are held
-+	 * in string intern table which requires no link pointers.  Much of
-+	 * the 32-bit flags field is unused by flags, so we can stuff a 16-bit
-+	 * field in there.
-+	 */
-+	duk_heaphdr_string hdr;
-+
-+	/* Note: we could try to stuff a partial hash (e.g. 16 bits) into the
-+	 * shared heap header.  Good hashing needs more hash bits though.
-+	 */
-+
-+	/* string hash */
-+#if defined(DUK_USE_STRHASH16)
-+	/* If 16-bit hash is in use, stuff it into duk_heaphdr_string flags. */
-+#else
-+	duk_uint32_t hash;
-+#endif
-+
-+	/* length in bytes (not counting NUL term) */
-+#if defined(DUK_USE_STRLEN16)
-+	duk_uint16_t blen16;
-+#else
-+	duk_uint32_t blen;
-+#endif
-+
-+	/* length in codepoints (must be E5 compatible) */
-+#if defined(DUK_USE_STRLEN16)
-+	duk_uint16_t clen16;
-+#else
-+	duk_uint32_t clen;
-+#endif
-+
-+	/*
-+	 *  String value of 'blen+1' bytes follows (+1 for NUL termination
-+	 *  convenience for C API).  No alignment needs to be guaranteed
-+	 *  for strings, but fields above should guarantee alignment-by-4
-+	 *  (but not alignment-by-8).
-+	 */
-+};
-+
-+/* The external string struct is defined even when the feature is inactive. */
-+struct duk_hstring_external {
-+	duk_hstring str;
-+
-+	/*
-+	 *  For an external string, the NUL-terminated string data is stored
-+	 *  externally.  The user must guarantee that data behind this pointer
-+	 *  doesn't change while it's used.
-+	 */
-+
-+	const duk_uint8_t *extdata;
-+};
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos);
-+
-+#endif  /* DUK_HSTRING_H_INCLUDED */
-+#line 1 "duk_hobject.h"
-+/*
-+ *  Heap object representation.
-+ *
-+ *  Heap objects are used for Ecmascript objects, arrays, and functions,
-+ *  but also for internal control like declarative and object environment
-+ *  records.  Compiled functions, native functions, and threads are also
-+ *  objects but with an extended C struct.
-+ *
-+ *  Objects provide the required Ecmascript semantics and exotic behaviors
-+ *  especially for property access.
-+ *
-+ *  Properties are stored in three conceptual parts:
-+ *
-+ *    1. A linear 'entry part' contains ordered key-value-attributes triples
-+ *       and is the main method of string properties.
-+ *
-+ *    2. An optional linear 'array part' is used for array objects to store a
-+ *       (dense) range of [0,N[ array indexed entries with default attributes
-+ *       (writable, enumerable, configurable).  If the array part would become
-+ *       sparse or non-default attributes are required, the array part is
-+ *       abandoned and moved to the 'entry part'.
-+ *
-+ *    3. An optional 'hash part' is used to optimize lookups of the entry
-+ *       part; it is used only for objects with sufficiently many properties
-+ *       and can be abandoned without loss of information.
-+ *
-+ *  These three conceptual parts are stored in a single memory allocated area.
-+ *  This minimizes memory allocation overhead but also means that all three
-+ *  parts are resized together, and makes property access a bit complicated.
-+ */
-+
-+#ifndef DUK_HOBJECT_H_INCLUDED
-+#define DUK_HOBJECT_H_INCLUDED
-+
-+/* there are currently 26 flag bits available */
-+#define DUK_HOBJECT_FLAG_EXTENSIBLE            DUK_HEAPHDR_USER_FLAG(0)   /* object is extensible */
-+#define DUK_HOBJECT_FLAG_CONSTRUCTABLE         DUK_HEAPHDR_USER_FLAG(1)   /* object is constructable */
-+#define DUK_HOBJECT_FLAG_BOUND                 DUK_HEAPHDR_USER_FLAG(2)   /* object established using Function.prototype.bind() */
-+#define DUK_HOBJECT_FLAG_COMPILEDFUNCTION      DUK_HEAPHDR_USER_FLAG(4)   /* object is a compiled function (duk_hcompiledfunction) */
-+#define DUK_HOBJECT_FLAG_NATIVEFUNCTION        DUK_HEAPHDR_USER_FLAG(5)   /* object is a native function (duk_hnativefunction) */
-+#define DUK_HOBJECT_FLAG_THREAD                DUK_HEAPHDR_USER_FLAG(6)   /* object is a thread (duk_hthread) */
-+#define DUK_HOBJECT_FLAG_ARRAY_PART            DUK_HEAPHDR_USER_FLAG(7)   /* object has an array part (a_size may still be 0) */
-+#define DUK_HOBJECT_FLAG_STRICT                DUK_HEAPHDR_USER_FLAG(8)   /* function: function object is strict */
-+#define DUK_HOBJECT_FLAG_NOTAIL                DUK_HEAPHDR_USER_FLAG(9)   /* function: function must not be tailcalled */
-+#define DUK_HOBJECT_FLAG_NEWENV                DUK_HEAPHDR_USER_FLAG(10)  /* function: create new environment when called (see duk_hcompiledfunction) */
-+#define DUK_HOBJECT_FLAG_NAMEBINDING           DUK_HEAPHDR_USER_FLAG(11)  /* function: create binding for func name (function templates only, used for named function expressions) */
-+#define DUK_HOBJECT_FLAG_CREATEARGS            DUK_HEAPHDR_USER_FLAG(12)  /* function: create an arguments object on function call */
-+#define DUK_HOBJECT_FLAG_ENVRECCLOSED          DUK_HEAPHDR_USER_FLAG(13)  /* envrec: (declarative) record is closed */
-+#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY          DUK_HEAPHDR_USER_FLAG(14)  /* 'Array' object, array length and index exotic behavior */
-+#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ      DUK_HEAPHDR_USER_FLAG(15)  /* 'String' object, array index exotic behavior */
-+#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS      DUK_HEAPHDR_USER_FLAG(16)  /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */
-+#define DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC        DUK_HEAPHDR_USER_FLAG(17)  /* Duktape/C (nativefunction) object, exotic 'length' */
-+#define DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ      DUK_HEAPHDR_USER_FLAG(18)  /* 'Buffer' object, array index exotic behavior, virtual 'length' */
-+#define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ       DUK_HEAPHDR_USER_FLAG(19)  /* 'Proxy' object */
-+/* bit 20 unused */
-+
-+#define DUK_HOBJECT_FLAG_CLASS_BASE            DUK_HEAPHDR_USER_FLAG_NUMBER(21)
-+#define DUK_HOBJECT_FLAG_CLASS_BITS            5
-+
-+#define DUK_HOBJECT_GET_CLASS_NUMBER(h)        \
-+	DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS)
-+#define DUK_HOBJECT_SET_CLASS_NUMBER(h,v)      \
-+	DUK_HEAPHDR_SET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS, (v))
-+
-+/* Macro for creating flag initializer from a class number.
-+ * Unsigned type cast is needed to avoid warnings about coercing
-+ * a signed integer to an unsigned one; the largest class values
-+ * have the highest bit (bit 31) set which causes this.
-+ */
-+#define DUK_HOBJECT_CLASS_AS_FLAGS(v)          (((duk_uint_t) (v)) << DUK_HOBJECT_FLAG_CLASS_BASE)
-+
-+/* E5 Section 8.6.2 + custom classes */
-+#define DUK_HOBJECT_CLASS_UNUSED               0
-+#define DUK_HOBJECT_CLASS_ARGUMENTS            1
-+#define DUK_HOBJECT_CLASS_ARRAY                2
-+#define DUK_HOBJECT_CLASS_BOOLEAN              3
-+#define DUK_HOBJECT_CLASS_DATE                 4
-+#define DUK_HOBJECT_CLASS_ERROR                5
-+#define DUK_HOBJECT_CLASS_FUNCTION             6
-+#define DUK_HOBJECT_CLASS_JSON                 7
-+#define DUK_HOBJECT_CLASS_MATH                 8
-+#define DUK_HOBJECT_CLASS_NUMBER               9
-+#define DUK_HOBJECT_CLASS_OBJECT               10
-+#define DUK_HOBJECT_CLASS_REGEXP               11
-+#define DUK_HOBJECT_CLASS_STRING               12
-+#define DUK_HOBJECT_CLASS_GLOBAL               13
-+#define DUK_HOBJECT_CLASS_OBJENV               14  /* custom */
-+#define DUK_HOBJECT_CLASS_DECENV               15  /* custom */
-+#define DUK_HOBJECT_CLASS_BUFFER               16  /* custom */
-+#define DUK_HOBJECT_CLASS_POINTER              17  /* custom */
-+#define DUK_HOBJECT_CLASS_THREAD               18  /* custom */
-+
-+#define DUK_HOBJECT_IS_OBJENV(h)               (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_OBJENV)
-+#define DUK_HOBJECT_IS_DECENV(h)               (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DECENV)
-+#define DUK_HOBJECT_IS_ENV(h)                  (DUK_HOBJECT_IS_OBJENV((h)) || DUK_HOBJECT_IS_DECENV((h)))
-+#define DUK_HOBJECT_IS_ARRAY(h)                (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAY)
-+#define DUK_HOBJECT_IS_COMPILEDFUNCTION(h)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)
-+#define DUK_HOBJECT_IS_NATIVEFUNCTION(h)       DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)
-+#define DUK_HOBJECT_IS_THREAD(h)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)
-+
-+#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
-+                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
-+                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)
-+
-+#define DUK_HOBJECT_IS_FUNCTION(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
-+                                                        DUK_HOBJECT_FLAG_BOUND | \
-+                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
-+                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)
-+
-+#define DUK_HOBJECT_IS_CALLABLE(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
-+                                                        DUK_HOBJECT_FLAG_BOUND | \
-+                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
-+                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)
-+
-+/* object has any exotic behavior(s) */
-+#define DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS      (DUK_HOBJECT_FLAG_EXOTIC_ARRAY | \
-+                                                DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS | \
-+                                                DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \
-+                                                DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC | \
-+                                                DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ | \
-+                                                DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
-+
-+#define DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR(h)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS)
-+
-+#define DUK_HOBJECT_HAS_EXTENSIBLE(h)          DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
-+#define DUK_HOBJECT_HAS_CONSTRUCTABLE(h)       DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
-+#define DUK_HOBJECT_HAS_BOUND(h)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)
-+#define DUK_HOBJECT_HAS_COMPILEDFUNCTION(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)
-+#define DUK_HOBJECT_HAS_NATIVEFUNCTION(h)      DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)
-+#define DUK_HOBJECT_HAS_THREAD(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)
-+#define DUK_HOBJECT_HAS_ARRAY_PART(h)          DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
-+#define DUK_HOBJECT_HAS_STRICT(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
-+#define DUK_HOBJECT_HAS_NOTAIL(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
-+#define DUK_HOBJECT_HAS_NEWENV(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
-+#define DUK_HOBJECT_HAS_NAMEBINDING(h)         DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
-+#define DUK_HOBJECT_HAS_CREATEARGS(h)          DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
-+#define DUK_HOBJECT_HAS_ENVRECCLOSED(h)        DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)
-+#define DUK_HOBJECT_HAS_EXOTIC_ARRAY(h)        DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
-+#define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
-+#define DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
-+#define DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(h)      DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)
-+#define DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ)
-+#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
-+
-+#define DUK_HOBJECT_SET_EXTENSIBLE(h)          DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
-+#define DUK_HOBJECT_SET_CONSTRUCTABLE(h)       DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
-+#define DUK_HOBJECT_SET_BOUND(h)               DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)
-+#define DUK_HOBJECT_SET_COMPILEDFUNCTION(h)    DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)
-+#define DUK_HOBJECT_SET_NATIVEFUNCTION(h)      DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)
-+#define DUK_HOBJECT_SET_THREAD(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)
-+#define DUK_HOBJECT_SET_ARRAY_PART(h)          DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
-+#define DUK_HOBJECT_SET_STRICT(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
-+#define DUK_HOBJECT_SET_NOTAIL(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
-+#define DUK_HOBJECT_SET_NEWENV(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
-+#define DUK_HOBJECT_SET_NAMEBINDING(h)         DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
-+#define DUK_HOBJECT_SET_CREATEARGS(h)          DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
-+#define DUK_HOBJECT_SET_ENVRECCLOSED(h)        DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)
-+#define DUK_HOBJECT_SET_EXOTIC_ARRAY(h)        DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
-+#define DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h)    DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
-+#define DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(h)    DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
-+#define DUK_HOBJECT_SET_EXOTIC_DUKFUNC(h)      DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)
-+#define DUK_HOBJECT_SET_EXOTIC_BUFFEROBJ(h)    DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ)
-+#define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ(h)     DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
-+
-+#define DUK_HOBJECT_CLEAR_EXTENSIBLE(h)        DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
-+#define DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h)     DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
-+#define DUK_HOBJECT_CLEAR_BOUND(h)             DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)
-+#define DUK_HOBJECT_CLEAR_COMPILEDFUNCTION(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)
-+#define DUK_HOBJECT_CLEAR_NATIVEFUNCTION(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)
-+#define DUK_HOBJECT_CLEAR_THREAD(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)
-+#define DUK_HOBJECT_CLEAR_ARRAY_PART(h)        DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
-+#define DUK_HOBJECT_CLEAR_STRICT(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
-+#define DUK_HOBJECT_CLEAR_NOTAIL(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
-+#define DUK_HOBJECT_CLEAR_NEWENV(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
-+#define DUK_HOBJECT_CLEAR_NAMEBINDING(h)       DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
-+#define DUK_HOBJECT_CLEAR_CREATEARGS(h)        DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
-+#define DUK_HOBJECT_CLEAR_ENVRECCLOSED(h)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)
-+#define DUK_HOBJECT_CLEAR_EXOTIC_ARRAY(h)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
-+#define DUK_HOBJECT_CLEAR_EXOTIC_STRINGOBJ(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
-+#define DUK_HOBJECT_CLEAR_EXOTIC_ARGUMENTS(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
-+#define DUK_HOBJECT_CLEAR_EXOTIC_DUKFUNC(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)
-+#define DUK_HOBJECT_CLEAR_EXOTIC_BUFFEROBJ(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ)
-+#define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
-+
-+/* flags used for property attributes in duk_propdesc and packed flags */
-+#define DUK_PROPDESC_FLAG_WRITABLE              (1 << 0)    /* E5 Section 8.6.1 */
-+#define DUK_PROPDESC_FLAG_ENUMERABLE            (1 << 1)    /* E5 Section 8.6.1 */
-+#define DUK_PROPDESC_FLAG_CONFIGURABLE          (1 << 2)    /* E5 Section 8.6.1 */
-+#define DUK_PROPDESC_FLAG_ACCESSOR              (1 << 3)    /* accessor */
-+#define DUK_PROPDESC_FLAG_VIRTUAL               (1 << 4)    /* property is virtual: used in duk_propdesc, never stored
-+                                                             * (used by e.g. buffer virtual properties)
-+                                                             */
-+#define DUK_PROPDESC_FLAGS_MASK                 (DUK_PROPDESC_FLAG_WRITABLE | \
-+                                                 DUK_PROPDESC_FLAG_ENUMERABLE | \
-+                                                 DUK_PROPDESC_FLAG_CONFIGURABLE | \
-+                                                 DUK_PROPDESC_FLAG_ACCESSOR)
-+
-+/* additional flags which are passed in the same flags argument as property
-+ * flags but are not stored in object properties.
-+ */
-+#define DUK_PROPDESC_FLAG_NO_OVERWRITE          (1 << 4)    /* internal define property: skip write silently if exists */
-+
-+/* convenience */
-+#define DUK_PROPDESC_FLAGS_NONE                 0
-+#define DUK_PROPDESC_FLAGS_W                    (DUK_PROPDESC_FLAG_WRITABLE)
-+#define DUK_PROPDESC_FLAGS_E                    (DUK_PROPDESC_FLAG_ENUMERABLE)
-+#define DUK_PROPDESC_FLAGS_C                    (DUK_PROPDESC_FLAG_CONFIGURABLE)
-+#define DUK_PROPDESC_FLAGS_WE                   (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE)
-+#define DUK_PROPDESC_FLAGS_WC                   (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)
-+#define DUK_PROPDESC_FLAGS_EC                   (DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)
-+#define DUK_PROPDESC_FLAGS_WEC                  (DUK_PROPDESC_FLAG_WRITABLE | \
-+                                                 DUK_PROPDESC_FLAG_ENUMERABLE | \
-+                                                 DUK_PROPDESC_FLAG_CONFIGURABLE)
-+
-+/*
-+ *  Macros to access the 'props' allocation.
-+ */
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+#define DUK_HOBJECT_GET_PROPS(heap,h) \
-+	((duk_uint8_t *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, ((duk_heaphdr *) (h))->h_extra16))
-+#define DUK_HOBJECT_SET_PROPS(heap,h,x) do { \
-+		((duk_heaphdr *) (h))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (x)); \
-+	} while (0)
-+#else
-+#define DUK_HOBJECT_GET_PROPS(heap,h) \
-+	((h)->props)
-+#define DUK_HOBJECT_SET_PROPS(heap,h,x) do { \
-+		(h)->props = (x); \
-+	} while (0)
-+#endif
-+
-+#if defined(DUK_USE_HOBJECT_LAYOUT_1)
-+/* LAYOUT 1 */
-+#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
-+	((duk_hstring **) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) \
-+	))
-+#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
-+	((duk_propvalue *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_hstring *) \
-+	))
-+#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
-+	((duk_uint8_t *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \
-+	))
-+#define DUK_HOBJECT_A_GET_BASE(heap,h) \
-+	((duk_tval *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) \
-+	))
-+#define DUK_HOBJECT_H_GET_BASE(heap,h) \
-+	((duk_uint32_t *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
-+			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
-+	))
-+#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \
-+	( \
-+		(n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
-+		(n_arr) * sizeof(duk_tval) + \
-+		(n_hash) * sizeof(duk_uint32_t) \
-+	)
-+#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash)  do { \
-+		(set_e_k) = (duk_hstring **) (p_base); \
-+		(set_e_pv) = (duk_propvalue *) ((set_e_k) + (n_ent)); \
-+		(set_e_f) = (duk_uint8_t *) ((set_e_pv) + (n_ent)); \
-+		(set_a) = (duk_tval *) ((set_e_f) + (n_ent)); \
-+		(set_h) = (duk_uint32_t *) ((set_a) + (n_arr)); \
-+	} while (0)
-+#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
-+/* LAYOUT 2 */
-+#if defined(DUK_USE_ALIGN_4)
-+#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) ((4 - (e_sz)) & 0x03)
-+#elif defined(DUK_USE_ALIGN_8)
-+#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) ((8 - (e_sz)) & 0x07)
-+#else
-+#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) 0
-+#endif
-+#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
-+	((duk_hstring **) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \
-+	))
-+#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
-+	((duk_propvalue *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) \
-+	))
-+#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
-+	((duk_uint8_t *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \
-+	))
-+#define DUK_HOBJECT_A_GET_BASE(heap,h) \
-+	((duk_tval *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
-+			DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) \
-+	))
-+#define DUK_HOBJECT_H_GET_BASE(heap,h) \
-+	((duk_uint32_t *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
-+			DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) + \
-+			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
-+	))
-+#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \
-+	( \
-+		(n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
-+		DUK_HOBJECT_E_FLAG_PADDING((n_ent)) + \
-+		(n_arr) * sizeof(duk_tval) + \
-+		(n_hash) * sizeof(duk_uint32_t) \
-+	)
-+#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash)  do { \
-+		(set_e_pv) = (duk_propvalue *) (p_base); \
-+		(set_e_k) = (duk_hstring **) ((set_e_pv) + (n_ent)); \
-+		(set_e_f) = (duk_uint8_t *) ((set_e_k) + (n_ent)); \
-+		(set_a) = (duk_tval *) (((duk_uint8_t *) (set_e_f)) + \
-+		                        sizeof(duk_uint8_t) * (n_ent) + \
-+		                        DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \
-+		(set_h) = (duk_uint32_t *) ((set_a) + (n_arr)); \
-+	} while (0)
-+#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
-+/* LAYOUT 3 */
-+#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
-+	((duk_hstring **) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) + \
-+			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
-+	))
-+#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
-+	((duk_propvalue *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) \
-+	))
-+#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
-+	((duk_uint8_t *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_propvalue) + sizeof(duk_hstring *)) + \
-+			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) + \
-+			DUK_HOBJECT_GET_HSIZE((h)) * sizeof(duk_uint32_t) \
-+	))
-+#define DUK_HOBJECT_A_GET_BASE(heap,h) \
-+	((duk_tval *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \
-+	))
-+#define DUK_HOBJECT_H_GET_BASE(heap,h) \
-+	((duk_uint32_t *) ( \
-+		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
-+			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_propvalue) + sizeof(duk_hstring *)) + \
-+			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
-+	))
-+#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \
-+	( \
-+		(n_ent) * (sizeof(duk_propvalue) + sizeof(duk_hstring *) + sizeof(duk_uint8_t)) + \
-+		(n_arr) * sizeof(duk_tval) + \
-+		(n_hash) * sizeof(duk_uint32_t) \
-+	)
-+#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash)  do { \
-+		(set_e_pv) = (duk_propvalue *) (p_base); \
-+		(set_a) = (duk_tval *) ((set_e_pv) + (n_ent)); \
-+		(set_e_k) = (duk_hstring **) ((set_a) + (n_arr)); \
-+		(set_h) = (duk_uint32_t *) ((set_e_k) + (n_ent)); \
-+		(set_e_f) = (duk_uint8_t *) ((set_h) + (n_hash)); \
-+	} while (0)
-+#else
-+#error invalid hobject layout defines
-+#endif  /* hobject property layout */
-+
-+#define DUK_HOBJECT_E_ALLOC_SIZE(h) \
-+	DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE((h)), DUK_HOBJECT_GET_ASIZE((h)), DUK_HOBJECT_GET_HSIZE((h)))
-+
-+#define DUK_HOBJECT_E_GET_KEY(heap,h,i)              (DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_E_GET_KEY_PTR(heap,h,i)          (&DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_E_GET_VALUE(heap,h,i)            (DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_E_GET_VALUE_PTR(heap,h,i)        (&DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_E_GET_VALUE_TVAL(heap,h,i)       (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v)
-+#define DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap,h,i)   (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v)
-+#define DUK_HOBJECT_E_GET_VALUE_GETTER(heap,h,i)     (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get)
-+#define DUK_HOBJECT_E_GET_VALUE_GETTER_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get)
-+#define DUK_HOBJECT_E_GET_VALUE_SETTER(heap,h,i)     (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set)
-+#define DUK_HOBJECT_E_GET_VALUE_SETTER_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set)
-+#define DUK_HOBJECT_E_GET_FLAGS(heap,h,i)            (DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_E_GET_FLAGS_PTR(heap,h,i)        (&DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_A_GET_VALUE(heap,h,i)            (DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_A_GET_VALUE_PTR(heap,h,i)        (&DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_H_GET_INDEX(heap,h,i)            (DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])
-+#define DUK_HOBJECT_H_GET_INDEX_PTR(heap,h,i)        (&DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])
-+
-+#define DUK_HOBJECT_E_SET_KEY(heap,h,i,k)  do { \
-+		DUK_HOBJECT_E_GET_KEY((heap), (h), (i)) = (k); \
-+	} while (0)
-+#define DUK_HOBJECT_E_SET_VALUE(heap,h,i,v)  do { \
-+		DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)) = (v); \
-+	} while (0)
-+#define DUK_HOBJECT_E_SET_VALUE_TVAL(heap,h,i,v)  do { \
-+		DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v = (v); \
-+	} while (0)
-+#define DUK_HOBJECT_E_SET_VALUE_GETTER(heap,h,i,v)  do { \
-+		DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get = (v); \
-+	} while (0)
-+#define DUK_HOBJECT_E_SET_VALUE_SETTER(heap,h,i,v)  do { \
-+		DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set = (v); \
-+	} while (0)
-+#define DUK_HOBJECT_E_SET_FLAGS(heap,h,i,f)  do { \
-+		DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (f); \
-+	} while (0)
-+#define DUK_HOBJECT_A_SET_VALUE(heap,h,i,v)  do { \
-+		DUK_HOBJECT_A_GET_VALUE((heap), (h), (i)) = (v); \
-+	} while (0)
-+#define DUK_HOBJECT_A_SET_VALUE_TVAL(heap,h,i,v) \
-+	DUK_HOBJECT_A_SET_VALUE((heap), (h), (i), (v))  /* alias for above */
-+#define DUK_HOBJECT_H_SET_INDEX(heap,h,i,v)  do { \
-+		DUK_HOBJECT_H_GET_INDEX((heap), (h), (i)) = (v); \
-+	} while (0)
-+
-+#define DUK_HOBJECT_E_SET_FLAG_BITS(heap,h,i,mask)  do { \
-+		DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)] |= (mask); \
-+	} while (0)
-+
-+#define DUK_HOBJECT_E_CLEAR_FLAG_BITS(heap,h,i,mask)  do { \
-+		DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)] &= ~(mask); \
-+	} while (0)
-+
-+#define DUK_HOBJECT_E_SLOT_IS_WRITABLE(heap,h,i)     ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_WRITABLE) != 0)
-+#define DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(heap,h,i)   ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)
-+#define DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(heap,h,i) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)
-+#define DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap,h,i)     ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ACCESSOR) != 0)
-+
-+#define DUK_HOBJECT_E_SLOT_SET_WRITABLE(heap,h,i)        DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE)
-+#define DUK_HOBJECT_E_SLOT_SET_ENUMERABLE(heap,h,i)      DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE)
-+#define DUK_HOBJECT_E_SLOT_SET_CONFIGURABLE(heap,h,i)    DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE)
-+#define DUK_HOBJECT_E_SLOT_SET_ACCESSOR(heap,h,i)        DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR)
-+
-+#define DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(heap,h,i)      DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE)
-+#define DUK_HOBJECT_E_SLOT_CLEAR_ENUMERABLE(heap,h,i)    DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE)
-+#define DUK_HOBJECT_E_SLOT_CLEAR_CONFIGURABLE(heap,h,i)  DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE)
-+#define DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(heap,h,i)      DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR)
-+
-+#define DUK_PROPDESC_IS_WRITABLE(p)             (((p)->flags & DUK_PROPDESC_FLAG_WRITABLE) != 0)
-+#define DUK_PROPDESC_IS_ENUMERABLE(p)           (((p)->flags & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)
-+#define DUK_PROPDESC_IS_CONFIGURABLE(p)         (((p)->flags & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)
-+#define DUK_PROPDESC_IS_ACCESSOR(p)             (((p)->flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0)
-+
-+#define DUK_HOBJECT_HASHIDX_UNUSED              0xffffffffUL
-+#define DUK_HOBJECT_HASHIDX_DELETED             0xfffffffeUL
-+
-+/*
-+ *  Macros for accessing size fields
-+ */
-+
-+#if defined(DUK_USE_OBJSIZES16)
-+#define DUK_HOBJECT_GET_ESIZE(h) ((h)->e_size16)
-+#define DUK_HOBJECT_SET_ESIZE(h,v) do { (h)->e_size16 = (v); } while (0)
-+#define DUK_HOBJECT_GET_ENEXT(h) ((h)->e_next16)
-+#define DUK_HOBJECT_SET_ENEXT(h,v) do { (h)->e_next16 = (v); } while (0)
-+#define DUK_HOBJECT_POSTINC_ENEXT(h) ((h)->e_next16++)
-+#define DUK_HOBJECT_GET_ASIZE(h) ((h)->a_size16)
-+#define DUK_HOBJECT_SET_ASIZE(h,v) do { (h)->a_size16 = (v); } while (0)
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+#define DUK_HOBJECT_GET_HSIZE(h) ((h)->h_size16)
-+#define DUK_HOBJECT_SET_HSIZE(h,v) do { (h)->h_size16 = (v); } while (0)
-+#else
-+#define DUK_HOBJECT_GET_HSIZE(h) 0
-+#define DUK_HOBJECT_SET_HSIZE(h,v) do { DUK_ASSERT((v) == 0); } while (0)
-+#endif
-+#else
-+#define DUK_HOBJECT_GET_ESIZE(h) ((h)->e_size)
-+#define DUK_HOBJECT_SET_ESIZE(h,v) do { (h)->e_size = (v); } while (0)
-+#define DUK_HOBJECT_GET_ENEXT(h) ((h)->e_next)
-+#define DUK_HOBJECT_SET_ENEXT(h,v) do { (h)->e_next = (v); } while (0)
-+#define DUK_HOBJECT_POSTINC_ENEXT(h) ((h)->e_next++)
-+#define DUK_HOBJECT_GET_ASIZE(h) ((h)->a_size)
-+#define DUK_HOBJECT_SET_ASIZE(h,v) do { (h)->a_size = (v); } while (0)
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+#define DUK_HOBJECT_GET_HSIZE(h) ((h)->h_size)
-+#define DUK_HOBJECT_SET_HSIZE(h,v) do { (h)->h_size = (v); } while (0)
-+#else
-+#define DUK_HOBJECT_GET_HSIZE(h) 0
-+#define DUK_HOBJECT_SET_HSIZE(h,v) do { DUK_ASSERT((v) == 0); } while (0)
-+#endif
-+#endif
-+
-+/*
-+ *  Misc
-+ */
-+
-+/* Maximum prototype traversal depth.  Sanity limit which handles e.g.
-+ * prototype loops (even complex ones like 1->2->3->4->2->3->4->2->3->4).
-+ */
-+#define DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY      10000L
-+
-+/* Maximum traversal depth for "bound function" chains. */
-+#define DUK_HOBJECT_BOUND_CHAIN_SANITY          10000L
-+
-+/*
-+ *  Ecmascript [[Class]]
-+ */
-+
-+/* range check not necessary because all 4-bit values are mapped */
-+#define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(n)  duk_class_number_to_stridx[(n)]
-+
-+#define DUK_HOBJECT_GET_CLASS_STRING(heap,h)          \
-+	DUK_HEAP_GET_STRING( \
-+		(heap), \
-+		DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(DUK_HOBJECT_GET_CLASS_NUMBER((h))) \
-+	)
-+
-+/*
-+ *  Macros for property handling
-+ */
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+#define DUK_HOBJECT_GET_PROTOTYPE(heap,h) \
-+	((duk_hobject *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->prototype16))
-+#define DUK_HOBJECT_SET_PROTOTYPE(heap,h,x) do { \
-+		(h)->prototype16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (x)); \
-+	} while (0)
-+#else
-+#define DUK_HOBJECT_GET_PROTOTYPE(heap,h) \
-+	((h)->prototype)
-+#define DUK_HOBJECT_SET_PROTOTYPE(heap,h,x) do { \
-+		(h)->prototype = (x); \
-+	} while (0)
-+#endif
-+
-+/* note: this updates refcounts */
-+#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr,h,p)       duk_hobject_set_prototype((thr), (h), (p))
-+
-+/*
-+ *  Resizing and hash behavior
-+ */
-+
-+/* Sanity limit on max number of properties (allocated, not necessarily used).
-+ * This is somewhat arbitrary, but if we're close to 2**32 properties some
-+ * algorithms will fail (e.g. hash size selection, next prime selection).
-+ * Also, we use negative array/entry table indices to indicate 'not found',
-+ * so anything above 0x80000000 will cause trouble now.
-+ */
-+#if defined(DUK_USE_OBJSIZES16)
-+#define DUK_HOBJECT_MAX_PROPERTIES       0x0000ffffUL
-+#else
-+#define DUK_HOBJECT_MAX_PROPERTIES       0x7fffffffUL   /* 2**31-1 ~= 2G properties */
-+#endif
-+
-+/* higher value conserves memory; also note that linear scan is cache friendly */
-+#define DUK_HOBJECT_E_USE_HASH_LIMIT     32
-+
-+/* hash size relative to entries size: for value X, approx. hash_prime(e_size + e_size / X) */
-+#define DUK_HOBJECT_H_SIZE_DIVISOR       4  /* hash size approx. 1.25 times entries size */
-+
-+/* if new_size < L * old_size, resize without abandon check; L = 3-bit fixed point, e.g. 9 -> 9/8 = 112.5% */
-+#define DUK_HOBJECT_A_FAST_RESIZE_LIMIT  9  /* 112.5%, i.e. new size less than 12.5% higher -> fast resize */
-+
-+/* if density < L, abandon array part, L = 3-bit fixed point, e.g. 2 -> 2/8 = 25% */
-+/* limit is quite low: one array entry is 8 bytes, one normal entry is 4+1+8+4 = 17 bytes (with hash entry) */
-+#define DUK_HOBJECT_A_ABANDON_LIMIT      2  /* 25%, i.e. less than 25% used -> abandon */
-+
-+/* internal align target for props allocation, must be 2*n for some n */
-+#if defined(DUK_USE_ALIGN_4)
-+#define DUK_HOBJECT_ALIGN_TARGET         4
-+#elif defined(DUK_USE_ALIGN_8)
-+#define DUK_HOBJECT_ALIGN_TARGET         8
-+#else
-+#define DUK_HOBJECT_ALIGN_TARGET         1
-+#endif
-+
-+/* controls for minimum entry part growth */
-+#define DUK_HOBJECT_E_MIN_GROW_ADD       16
-+#define DUK_HOBJECT_E_MIN_GROW_DIVISOR   8  /* 2^3 -> 1/8 = 12.5% min growth */
-+
-+/* controls for minimum array part growth */
-+#define DUK_HOBJECT_A_MIN_GROW_ADD       16
-+#define DUK_HOBJECT_A_MIN_GROW_DIVISOR   8  /* 2^3 -> 1/8 = 12.5% min growth */
-+
-+/* probe sequence */
-+#define DUK_HOBJECT_HASH_INITIAL(hash,h_size)  ((hash) % (h_size))
-+#define DUK_HOBJECT_HASH_PROBE_STEP(hash)      DUK_UTIL_GET_HASH_PROBE_STEP((hash))
-+
-+/*
-+ *  PC-to-line constants
-+ */
-+
-+#define DUK_PC2LINE_SKIP    64
-+
-+/* maximum length for a SKIP-1 diffstream: 35 bits per entry, rounded up to bytes */
-+#define DUK_PC2LINE_MAX_DIFF_LENGTH    (((DUK_PC2LINE_SKIP - 1) * 35 + 7) / 8)
-+
-+/*
-+ *  Struct defs
-+ */
-+
-+struct duk_propaccessor {
-+	duk_hobject *get;
-+	duk_hobject *set;
-+};
-+
-+union duk_propvalue {
-+	/* The get/set pointers could be 16-bit pointer compressed but it
-+	 * would make no difference on 32-bit platforms because duk_tval is
-+	 * 8 bytes or more anyway.
-+	 */
-+	duk_tval v;
-+	duk_propaccessor a;
-+};
-+
-+struct duk_propdesc {
-+	/* read-only values 'lifted' for ease of use */
-+	duk_small_int_t flags;
-+	duk_hobject *get;
-+	duk_hobject *set;
-+
-+	/* for updating (all are set to < 0 for virtual properties) */
-+	duk_int_t e_idx;  /* prop index in 'entry part', < 0 if not there */
-+	duk_int_t h_idx;  /* prop index in 'hash part', < 0 if not there */
-+	duk_int_t a_idx;  /* prop index in 'array part', < 0 if not there */
-+};
-+
-+struct duk_hobject {
-+	duk_heaphdr hdr;
-+
-+	/*
-+	 *  'props' contains {key,value,flags} entries, optional array entries, and
-+	 *  an optional hash lookup table for non-array entries in a single 'sliced'
-+	 *  allocation.  There are several layout options, which differ slightly in
-+	 *  generated code size/speed and alignment/padding; duk_features.h selects
-+	 *  the layout used.
-+	 *
-+	 *  Layout 1 (DUK_USE_HOBJECT_LAYOUT_1):
-+	 *
-+	 *    e_size * sizeof(duk_hstring *)         bytes of   entry keys (e_next gc reachable)
-+	 *    e_size * sizeof(duk_propvalue)         bytes of   entry values (e_next gc reachable)
-+	 *    e_size * sizeof(duk_uint8_t)           bytes of   entry flags (e_next gc reachable)
-+	 *    a_size * sizeof(duk_tval)              bytes of   (opt) array values (plain only) (all gc reachable)
-+	 *    h_size * sizeof(duk_uint32_t)          bytes of   (opt) hash indexes to entries (e_size),
-+	 *                                                      0xffffffffUL = unused, 0xfffffffeUL = deleted
-+	 *
-+	 *  Layout 2 (DUK_USE_HOBJECT_LAYOUT_2):
-+	 *
-+	 *    e_size * sizeof(duk_propvalue)         bytes of   entry values (e_next gc reachable)
-+	 *    e_size * sizeof(duk_hstring *)         bytes of   entry keys (e_next gc reachable)
-+	 *    e_size * sizeof(duk_uint8_t) + pad     bytes of   entry flags (e_next gc reachable)
-+	 *    a_size * sizeof(duk_tval)              bytes of   (opt) array values (plain only) (all gc reachable)
-+	 *    h_size * sizeof(duk_uint32_t)          bytes of   (opt) hash indexes to entries (e_size),
-+	 *                                                      0xffffffffUL = unused, 0xfffffffeUL = deleted
-+	 *
-+	 *  Layout 3 (DUK_USE_HOBJECT_LAYOUT_3):
-+	 *
-+	 *    e_size * sizeof(duk_propvalue)         bytes of   entry values (e_next gc reachable)
-+	 *    a_size * sizeof(duk_tval)              bytes of   (opt) array values (plain only) (all gc reachable)
-+	 *    e_size * sizeof(duk_hstring *)         bytes of   entry keys (e_next gc reachable)
-+	 *    h_size * sizeof(duk_uint32_t)          bytes of   (opt) hash indexes to entries (e_size),
-+	 *                                                      0xffffffffUL = unused, 0xfffffffeUL = deleted
-+	 *    e_size * sizeof(duk_uint8_t)           bytes of   entry flags (e_next gc reachable)
-+	 *
-+	 *  In layout 1, the 'e_next' count is rounded to 4 or 8 on platforms
-+	 *  requiring 4 or 8 byte alignment.  This ensures proper alignment
-+	 *  for the entries, at the cost of memory footprint.  However, it's
-+	 *  probably preferable to use another layout on such platforms instead.
-+	 *
-+	 *  In layout 2, the key and value parts are swapped to avoid padding
-+	 *  the key array on platforms requiring alignment by 8.  The flags part
-+	 *  is padded to get alignment for array entries.  The 'e_next' count does
-+	 *  not need to be rounded as in layout 1.
-+	 *
-+	 *  In layout 3, entry values and array values are always aligned properly,
-+	 *  and assuming pointers are at most 8 bytes, so are the entry keys.  Hash
-+	 *  indices will be properly aligned (assuming pointers are at least 4 bytes).
-+	 *  Finally, flags don't need additional alignment.  This layout provides
-+	 *  compact allocations without padding (even on platforms with alignment
-+	 *  requirements) at the cost of a bit slower lookups.
-+	 *
-+	 *  Objects with few keys don't have a hash index; keys are looked up linearly,
-+	 *  which is cache efficient because the keys are consecutive.  Larger objects
-+	 *  have a hash index part which contains integer indexes to the entries part.
-+	 *
-+	 *  A single allocation reduces memory allocation overhead but requires more
-+	 *  work when any part needs to be resized.  A sliced allocation for entries
-+	 *  makes linear key matching faster on most platforms (more locality) and
-+	 *  skimps on flags size (which would be followed by 3 bytes of padding in
-+	 *  most architectures if entries were placed in a struct).
-+	 *
-+	 *  'props' also contains internal properties distinguished with a non-BMP
-+	 *  prefix.  Often used properties should be placed early in 'props' whenever
-+	 *  possible to make accessing them as fast a possible.
-+	 */
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+	/* Located in duk_heaphdr h_extra16.  Subclasses of duk_hobject (like
-+	 * duk_hcompiledfunction) are not free to use h_extra16 for this reason.
-+	 */
-+#else
-+	duk_uint8_t *props;
-+#endif
-+
-+	/* prototype: the only internal property lifted outside 'e' as it is so central */
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t prototype16;
-+#else
-+	duk_hobject *prototype;
-+#endif
-+
-+#if defined(DUK_USE_OBJSIZES16)
-+	duk_uint16_t e_size16;
-+	duk_uint16_t e_next16;
-+	duk_uint16_t a_size16;
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	duk_uint16_t h_size16;
-+#endif
-+#else
-+	duk_uint32_t e_size;  /* entry part size */
-+	duk_uint32_t e_next;  /* index for next new key ([0,e_next[ are gc reachable) */
-+	duk_uint32_t a_size;  /* array part size (entirely gc reachable) */
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	duk_uint32_t h_size;  /* hash part size or 0 if unused */
-+#endif
-+#endif
-+};
-+
-+/*
-+ *  Exposed data
-+ */
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL duk_uint8_t duk_class_number_to_stridx[32];
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+/* alloc and init */
-+DUK_INTERNAL_DECL duk_hobject *duk_hobject_alloc(duk_heap *heap, duk_uint_t hobject_flags);
-+#if 0  /* unused */
-+DUK_INTERNAL_DECL duk_hobject *duk_hobject_alloc_checked(duk_hthread *thr, duk_uint_t hobject_flags);
-+#endif
-+DUK_INTERNAL_DECL duk_hcompiledfunction *duk_hcompiledfunction_alloc(duk_heap *heap, duk_uint_t hobject_flags);
-+DUK_INTERNAL_DECL duk_hnativefunction *duk_hnativefunction_alloc(duk_heap *heap, duk_uint_t hobject_flags);
-+DUK_INTERNAL_DECL duk_hthread *duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_flags);
-+
-+/* low-level property functions */
-+DUK_INTERNAL_DECL void duk_hobject_find_existing_entry(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *e_idx, duk_int_t *h_idx);
-+DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_hstring *key);
-+DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_entry_tval_ptr_and_attrs(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *out_attrs);
-+DUK_INTERNAL_DECL duk_tval *duk_hobject_find_existing_array_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_uarridx_t i);
-+
-+/* core property functions */
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key);
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_tval *tv_val, duk_bool_t throw_flag);
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_delprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_bool_t throw_flag);
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_hasprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key);
-+
-+/* internal property functions */
-+#define DUK_DELPROP_FLAG_THROW  (1 << 0)
-+#define DUK_DELPROP_FLAG_FORCE  (1 << 1)
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags);
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_hasprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key);
-+DUK_INTERNAL_DECL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags);
-+DUK_INTERNAL_DECL void duk_hobject_define_property_internal_arridx(duk_hthread *thr, duk_hobject *obj, duk_uarridx_t arr_idx, duk_small_uint_t flags);
-+DUK_INTERNAL_DECL void duk_hobject_define_accessor_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_hobject *getter, duk_hobject *setter, duk_small_uint_t propflags);
-+DUK_INTERNAL_DECL void duk_hobject_set_length(duk_hthread *thr, duk_hobject *obj, duk_uint32_t length);  /* XXX: duk_uarridx_t? */
-+DUK_INTERNAL_DECL void duk_hobject_set_length_zero(duk_hthread *thr, duk_hobject *obj);
-+DUK_INTERNAL_DECL duk_uint32_t duk_hobject_get_length(duk_hthread *thr, duk_hobject *obj);  /* XXX: duk_uarridx_t? */
-+
-+/* helpers for defineProperty() and defineProperties() */
-+DUK_INTERNAL_DECL
-+void duk_hobject_prepare_property_descriptor(duk_context *ctx,
-+                                             duk_idx_t idx_in,
-+                                             duk_uint_t *out_defprop_flags,
-+                                             duk_idx_t *out_idx_value,
-+                                             duk_hobject **out_getter,
-+                                             duk_hobject **out_setter);
-+DUK_INTERNAL_DECL
-+void duk_hobject_define_property_helper(duk_context *ctx,
-+                                        duk_uint_t defprop_flags,
-+                                        duk_hobject *obj,
-+                                        duk_hstring *key,
-+                                        duk_idx_t idx_value,
-+                                        duk_hobject *get,
-+                                        duk_hobject *set);
-+
-+/* Object built-in methods */
-+DUK_INTERNAL_DECL duk_ret_t duk_hobject_object_get_own_property_descriptor(duk_context *ctx);
-+DUK_INTERNAL_DECL void duk_hobject_object_seal_freeze_helper(duk_hthread *thr, duk_hobject *obj, duk_bool_t is_freeze);
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_object_is_sealed_frozen_helper(duk_hthread *thr, duk_hobject *obj, duk_bool_t is_frozen);
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_object_ownprop_helper(duk_context *ctx, duk_small_uint_t required_desc_flags);
-+
-+/* internal properties */
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_get_internal_value(duk_heap *heap, duk_hobject *obj, duk_tval *tv);
-+DUK_INTERNAL_DECL duk_hstring *duk_hobject_get_internal_value_string(duk_heap *heap, duk_hobject *obj);
-+DUK_INTERNAL_DECL duk_hbuffer *duk_hobject_get_internal_value_buffer(duk_heap *heap, duk_hobject *obj);
-+
-+/* hobject management functions */
-+DUK_INTERNAL_DECL void duk_hobject_compact_props(duk_hthread *thr, duk_hobject *obj);
-+
-+/* ES6 proxy */
-+#if defined(DUK_USE_ES6_PROXY)
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_proxy_check(duk_hthread *thr, duk_hobject *obj, duk_hobject **out_target, duk_hobject **out_handler);
-+#endif
-+
-+/* enumeration */
-+DUK_INTERNAL_DECL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint_t enum_flags);
-+DUK_INTERNAL_DECL duk_ret_t duk_hobject_get_enumerated_keys(duk_context *ctx, duk_small_uint_t enum_flags);
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_enumerator_next(duk_context *ctx, duk_bool_t get_value);
-+
-+/* macros */
-+DUK_INTERNAL_DECL void duk_hobject_set_prototype(duk_hthread *thr, duk_hobject *h, duk_hobject *p);
-+
-+/* finalization */
-+DUK_INTERNAL_DECL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj);
-+
-+/* pc2line */
-+#if defined(DUK_USE_PC2LINE)
-+DUK_INTERNAL_DECL void duk_hobject_pc2line_pack(duk_hthread *thr, duk_compiler_instr *instrs, duk_uint_fast32_t length);
-+DUK_INTERNAL_DECL duk_uint_fast32_t duk_hobject_pc2line_query(duk_context *ctx, duk_idx_t idx_func, duk_uint_fast32_t pc);
-+#endif
-+
-+/* misc */
-+DUK_INTERNAL_DECL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *thr, duk_hobject *h, duk_hobject *p, duk_bool_t ignore_loop);
-+
-+#endif  /* DUK_HOBJECT_H_INCLUDED */
-+#line 1 "duk_hcompiledfunction.h"
-+/*
-+ *  Heap compiled function (Ecmascript function) representation.
-+ *
-+ *  There is a single data buffer containing the Ecmascript function's
-+ *  bytecode, constants, and inner functions.
-+ */
-+
-+#ifndef DUK_HCOMPILEDFUNCTION_H_INCLUDED
-+#define DUK_HCOMPILEDFUNCTION_H_INCLUDED
-+
-+/*
-+ *  Field accessor macros
-+ */
-+
-+/* XXX: casts could be improved, especially for GET/SET DATA */
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \
-+	((duk_hbuffer_fixed *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->data16))
-+#define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \
-+		(h)->data16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
-+	} while (0)
-+#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h)  \
-+	((duk_hobject **) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->funcs16)))
-+#define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap,h,v)  do { \
-+		(h)->funcs16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
-+	} while (0)
-+#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h)  \
-+	((duk_instr_t *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->bytecode16)))
-+#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap,h,v)  do { \
-+		(h)->bytecode16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
-+	} while (0)
-+#else
-+#define DUK_HCOMPILEDFUNCTION_GET_DATA(heap,h) \
-+	((duk_hbuffer_fixed *) (h)->data)
-+#define DUK_HCOMPILEDFUNCTION_SET_DATA(heap,h,v) do { \
-+		(h)->data = (duk_hbuffer *) (v); \
-+	} while (0)
-+#define DUK_HCOMPILEDFUNCTION_GET_FUNCS(heap,h)  \
-+	((h)->funcs)
-+#define DUK_HCOMPILEDFUNCTION_SET_FUNCS(heap,h,v)  do { \
-+		(h)->funcs = (v); \
-+	} while (0)
-+#define DUK_HCOMPILEDFUNCTION_GET_BYTECODE(heap,h)  \
-+	((h)->bytecode)
-+#define DUK_HCOMPILEDFUNCTION_SET_BYTECODE(heap,h,v)  do { \
-+		(h)->bytecode = (v); \
-+	} while (0)
-+#endif
-+
-+/*
-+ *  Accessor macros for function specific data areas
-+ */
-+
-+/* Note: assumes 'data' is always a fixed buffer */
-+#define DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE(heap,h)  \
-+	DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h)))
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap,h)  \
-+	((duk_tval *) DUK_HCOMPILEDFUNCTION_GET_BUFFER_BASE((heap), (h)))
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap,h)  \
-+	DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h))
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(heap,h)  \
-+	DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h))
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap,h)  \
-+	((duk_tval *) DUK_HCOMPILEDFUNCTION_GET_FUNCS((heap), (h)))
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap,h)  \
-+	((duk_hobject **) DUK_HCOMPILEDFUNCTION_GET_BYTECODE((heap), (h)))
-+
-+/* XXX: double evaluation of DUK_HCOMPILEDFUNCTION_GET_DATA() */
-+#define DUK_HCOMPILEDFUNCTION_GET_CODE_END(heap,h)  \
-+	((duk_instr_t *) (DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPILEDFUNCTION_GET_DATA((heap), (h))) + \
-+	                DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA((heap), h))))
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE(heap,h)  \
-+	( \
-+	 (duk_size_t) \
-+	 ( \
-+	   ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_END((heap), (h))) - \
-+	   ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE((heap), (h))) \
-+	 ) \
-+	)
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE(heap,h)  \
-+	( \
-+	 (duk_size_t) \
-+	 ( \
-+	   ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_END((heap), (h))) - \
-+	   ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE((heap), (h))) \
-+	 ) \
-+	)
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(heap,h)  \
-+	( \
-+	 (duk_size_t) \
-+	 ( \
-+	   ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END((heap),(h))) - \
-+	   ((const duk_uint8_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE((heap),(h))) \
-+	 ) \
-+	)
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(heap,h)  \
-+	((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval)))
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(heap,h)  \
-+	((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *)))
-+
-+#define DUK_HCOMPILEDFUNCTION_GET_CODE_COUNT(heap,h)  \
-+	((duk_size_t) (DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t)))
-+
-+
-+/*
-+ *  Main struct
-+ */
-+
-+struct duk_hcompiledfunction {
-+	/* shared object part */
-+	duk_hobject obj;
-+
-+	/*
-+	 *  Pointers to function data area for faster access.  Function
-+	 *  data is a buffer shared between all closures of the same
-+	 *  "template" function.  The data buffer is always fixed (non-
-+	 *  dynamic, hence stable), with a layout as follows:
-+	 *
-+	 *    constants (duk_tval)
-+	 *    inner functions (duk_hobject *)
-+	 *    bytecode (duk_instr_t)
-+	 *
-+	 *  Note: bytecode end address can be computed from 'data' buffer
-+	 *  size.  It is not strictly necessary functionally, assuming
-+	 *  bytecode never jumps outside its allocated area.  However,
-+	 *  it's a safety/robustness feature for avoiding the chance of
-+	 *  executing random data as bytecode due to a compiler error.
-+	 *
-+	 *  Note: values in the data buffer must be incref'd (they will
-+	 *  be decref'd on release) for every compiledfunction referring
-+	 *  to the 'data' element.
-+	 */
-+
-+	/* Data area, fixed allocation, stable data ptrs. */
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t data16;
-+#else
-+	duk_hbuffer *data;
-+#endif
-+
-+	/* No need for constants pointer (= same as data).
-+	 *
-+	 * When using 16-bit packing alignment to 4 is nice.  'funcs' will be
-+	 * 4-byte aligned because 'constants' are duk_tvals.  For now the
-+	 * inner function pointers are not compressed, so that 'bytecode' will
-+	 * also be 4-byte aligned.
-+	 */
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t funcs16;
-+	duk_uint16_t bytecode16;
-+#else
-+	duk_hobject **funcs;
-+	duk_instr_t *bytecode;
-+#endif
-+
-+	/*
-+	 *  'nregs' registers are allocated on function entry, at most 'nargs'
-+	 *  are initialized to arguments, and the rest to undefined.  Arguments
-+	 *  above 'nregs' are not mapped to registers.  All registers in the
-+	 *  active stack range must be initialized because they are GC reachable.
-+	 *  'nargs' is needed so that if the function is given more than 'nargs'
-+	 *  arguments, the additional arguments do not 'clobber' registers
-+	 *  beyond 'nregs' which must be consistently initialized to undefined.
-+	 *
-+	 *  Usually there is no need to know which registers are mapped to
-+	 *  local variables.  Registers may be allocated to variable in any
-+	 *  way (even including gaps).  However, a register-variable mapping
-+	 *  must be the same for the duration of the function execution and
-+	 *  the register cannot be used for anything else.
-+	 *
-+	 *  When looking up variables by name, the '_Varmap' map is used.
-+	 *  When an activation closes, registers mapped to arguments are
-+	 *  copied into the environment record based on the same map.  The
-+	 *  reverse map (from register to variable) is not currently needed
-+	 *  at run time, except for debugging, so it is not maintained.
-+	 */
-+
-+	duk_uint16_t nregs;                /* regs to allocate */
-+	duk_uint16_t nargs;                /* number of arguments allocated to regs */
-+
-+	/*
-+	 *  Additional control information is placed into the object itself
-+	 *  as internal properties to avoid unnecessary fields for the
-+	 *  majority of functions.  The compiler tries to omit internal
-+	 *  control fields when possible.
-+	 *
-+	 *  Function templates:
-+	 *
-+	 *    {
-+	 *      name: "func",    // declaration, named function expressions
-+	 *      fileName: <debug info for creating nice errors>
-+	 *      _Varmap: { "arg1": 0, "arg2": 1, "varname": 2 },
-+	 *      _Formals: [ "arg1", "arg2" ],
-+	 *      _Source: "function func(arg1, arg2) { ... }",
-+	 *      _Pc2line: <debug info for pc-to-line mapping>,
-+	 *    }
-+	 *
-+	 *  Function instances:
-+	 *
-+	 *    {
-+	 *      length: 2,
-+	 *      prototype: { constructor: <func> },
-+	 *      caller: <thrower>,
-+	 *      arguments: <thrower>,
-+	 *      name: "func",    // declaration, named function expressions
-+	 *      fileName: <debug info for creating nice errors>
-+	 *      _Varmap: { "arg1": 0, "arg2": 1, "varname": 2 },
-+	 *      _Formals: [ "arg1", "arg2" ],
-+	 *      _Source: "function func(arg1, arg2) { ... }",
-+	 *      _Pc2line: <debug info for pc-to-line mapping>,
-+	 *      _Varenv: <variable environment of closure>,
-+	 *      _Lexenv: <lexical environment of closure (if differs from _Varenv)>
-+	 *    }
-+	 *
-+	 *  More detailed description of these properties can be found
-+	 *  in the documentation.
-+	 */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	/* Line number range for function.  Needed during debugging to
-+	 * determine active breakpoints.
-+	 */
-+	duk_uint32_t start_line;
-+	duk_uint32_t end_line;
-+#endif
-+};
-+
-+#endif  /* DUK_HCOMPILEDFUNCTION_H_INCLUDED */
-+#line 1 "duk_hnativefunction.h"
-+/*
-+ *  Heap native function representation.
-+ */
-+
-+#ifndef DUK_HNATIVEFUNCTION_H_INCLUDED
-+#define DUK_HNATIVEFUNCTION_H_INCLUDED
-+
-+#define DUK_HNATIVEFUNCTION_NARGS_VARARGS  ((duk_int16_t) -1)
-+#define DUK_HNATIVEFUNCTION_NARGS_MAX      ((duk_int16_t) 0x7fff)
-+
-+struct duk_hnativefunction {
-+	/* shared object part */
-+	duk_hobject obj;
-+
-+	duk_c_function func;
-+	duk_int16_t nargs;
-+	duk_int16_t magic;
-+
-+	/* The 'magic' field allows an opaque 16-bit field to be accessed by the
-+	 * Duktape/C function.  This allows, for instance, the same native function
-+	 * to be used for a set of very similar functions, with the 'magic' field
-+	 * providing the necessary non-argument flags / values to guide the behavior
-+	 * of the native function.  The value is signed on purpose: it is easier to
-+	 * convert a signed value to unsigned (simply AND with 0xffff) than vice
-+	 * versa.
-+	 *
-+	 * Note: cannot place nargs/magic into the heaphdr flags, because
-+	 * duk_hobject takes almost all flags already (and needs the spare).
-+	 */
-+};
-+
-+#endif  /* DUK_HNATIVEFUNCTION_H_INCLUDED */
-+#line 1 "duk_hthread.h"
-+/*
-+ *  Heap thread object representation.
-+ *
-+ *  duk_hthread is also the 'context' (duk_context) for exposed APIs
-+ *  which mostly operate on the topmost frame of the value stack.
-+ */
-+
-+#ifndef DUK_HTHREAD_H_INCLUDED
-+#define DUK_HTHREAD_H_INCLUDED
-+
-+/*
-+ *  Stack constants
-+ */
-+
-+#define DUK_VALSTACK_GROW_STEP          128     /* roughly 1 kiB */
-+#define DUK_VALSTACK_SHRINK_THRESHOLD   256     /* roughly 2 kiB */
-+#define DUK_VALSTACK_SHRINK_SPARE       64      /* roughly 0.5 kiB */
-+#define DUK_VALSTACK_INITIAL_SIZE       128     /* roughly 1.0 kiB -> but rounds up to DUK_VALSTACK_GROW_STEP in practice */
-+#define DUK_VALSTACK_INTERNAL_EXTRA     64      /* internal extra elements assumed on function entry,
-+                                                 * always added to user-defined 'extra' for e.g. the
-+                                                 * duk_check_stack() call.
-+                                                 */
-+#define DUK_VALSTACK_API_ENTRY_MINIMUM  DUK_API_ENTRY_STACK
-+                                                /* number of elements guaranteed to be user accessible
-+                                                 * (in addition to call arguments) on Duktape/C function entry.
-+                                                 */
-+
-+/* Note: DUK_VALSTACK_INITIAL_SIZE must be >= DUK_VALSTACK_API_ENTRY_MINIMUM
-+ * + DUK_VALSTACK_INTERNAL_EXTRA so that the initial stack conforms to spare
-+ * requirements.
-+ */
-+
-+#define DUK_VALSTACK_DEFAULT_MAX        1000000L
-+
-+#define DUK_CALLSTACK_GROW_STEP         8       /* roughly 256 bytes */
-+#define DUK_CALLSTACK_SHRINK_THRESHOLD  16      /* roughly 512 bytes */
-+#define DUK_CALLSTACK_SHRINK_SPARE      8       /* roughly 256 bytes */
-+#define DUK_CALLSTACK_INITIAL_SIZE      8
-+#define DUK_CALLSTACK_DEFAULT_MAX       10000L
-+
-+#define DUK_CATCHSTACK_GROW_STEP         4      /* roughly 64 bytes */
-+#define DUK_CATCHSTACK_SHRINK_THRESHOLD  8      /* roughly 128 bytes */
-+#define DUK_CATCHSTACK_SHRINK_SPARE      4      /* roughly 64 bytes */
-+#define DUK_CATCHSTACK_INITIAL_SIZE      4
-+#define DUK_CATCHSTACK_DEFAULT_MAX       10000L
-+
-+/*
-+ *  Activation defines
-+ */
-+
-+#define DUK_ACT_FLAG_STRICT             (1 << 0)  /* function executes in strict mode */
-+#define DUK_ACT_FLAG_TAILCALLED         (1 << 1)  /* activation has tailcalled one or more times */
-+#define DUK_ACT_FLAG_CONSTRUCT          (1 << 2)  /* function executes as a constructor (called via "new") */
-+#define DUK_ACT_FLAG_PREVENT_YIELD      (1 << 3)  /* activation prevents yield (native call or "new") */
-+#define DUK_ACT_FLAG_DIRECT_EVAL        (1 << 4)  /* activation is a direct eval call */
-+#define DUK_ACT_FLAG_BREAKPOINT_ACTIVE  (1 << 5)  /* activation has active breakpoint(s) */
-+
-+#define DUK_ACT_GET_FUNC(act)        ((act)->func)
-+
-+/*
-+ *  Flags for __FILE__ / __LINE__ registered into tracedata
-+ */
-+
-+#define DUK_TB_FLAG_NOBLAME_FILELINE   (1 << 0)  /* don't report __FILE__ / __LINE__ as fileName/lineNumber */
-+
-+/*
-+ *  Catcher defines
-+ */
-+
-+/* flags field: LLLLLLFT, L = label (24 bits), F = flags (4 bits), T = type (4 bits) */
-+#define DUK_CAT_TYPE_MASK            0x0000000fUL
-+#define DUK_CAT_TYPE_BITS            4
-+#define DUK_CAT_LABEL_MASK           0xffffff00UL
-+#define DUK_CAT_LABEL_BITS           24
-+#define DUK_CAT_LABEL_SHIFT          8
-+
-+#define DUK_CAT_FLAG_CATCH_ENABLED          (1 << 4)   /* catch part will catch */
-+#define DUK_CAT_FLAG_FINALLY_ENABLED        (1 << 5)   /* finally part will catch */
-+#define DUK_CAT_FLAG_CATCH_BINDING_ENABLED  (1 << 6)   /* request to create catch binding */
-+#define DUK_CAT_FLAG_LEXENV_ACTIVE          (1 << 7)   /* catch or with binding is currently active */
-+
-+#define DUK_CAT_TYPE_UNKNOWN         0
-+#define DUK_CAT_TYPE_TCF             1
-+#define DUK_CAT_TYPE_LABEL           2
-+
-+#define DUK_CAT_GET_TYPE(c)          ((c)->flags & DUK_CAT_TYPE_MASK)
-+#define DUK_CAT_GET_LABEL(c)         (((c)->flags & DUK_CAT_LABEL_MASK) >> DUK_CAT_LABEL_SHIFT)
-+
-+#define DUK_CAT_HAS_CATCH_ENABLED(c)           ((c)->flags & DUK_CAT_FLAG_CATCH_ENABLED)
-+#define DUK_CAT_HAS_FINALLY_ENABLED(c)         ((c)->flags & DUK_CAT_FLAG_FINALLY_ENABLED)
-+#define DUK_CAT_HAS_CATCH_BINDING_ENABLED(c)   ((c)->flags & DUK_CAT_FLAG_CATCH_BINDING_ENABLED)
-+#define DUK_CAT_HAS_LEXENV_ACTIVE(c)           ((c)->flags & DUK_CAT_FLAG_LEXENV_ACTIVE)
-+
-+#define DUK_CAT_SET_CATCH_ENABLED(c)    do { \
-+		(c)->flags |= DUK_CAT_FLAG_CATCH_ENABLED; \
-+	} while (0)
-+#define DUK_CAT_SET_FINALLY_ENABLED(c)  do { \
-+		(c)->flags |= DUK_CAT_FLAG_FINALLY_ENABLED; \
-+	} while (0)
-+#define DUK_CAT_SET_CATCH_BINDING_ENABLED(c)    do { \
-+		(c)->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \
-+	} while (0)
-+#define DUK_CAT_SET_LEXENV_ACTIVE(c)    do { \
-+		(c)->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE; \
-+	} while (0)
-+
-+#define DUK_CAT_CLEAR_CATCH_ENABLED(c)    do { \
-+		(c)->flags &= ~DUK_CAT_FLAG_CATCH_ENABLED; \
-+	} while (0)
-+#define DUK_CAT_CLEAR_FINALLY_ENABLED(c)  do { \
-+		(c)->flags &= ~DUK_CAT_FLAG_FINALLY_ENABLED; \
-+	} while (0)
-+#define DUK_CAT_CLEAR_CATCH_BINDING_ENABLED(c)    do { \
-+		(c)->flags &= ~DUK_CAT_FLAG_CATCH_BINDING_ENABLED; \
-+	} while (0)
-+#define DUK_CAT_CLEAR_LEXENV_ACTIVE(c)    do { \
-+		(c)->flags &= ~DUK_CAT_FLAG_LEXENV_ACTIVE; \
-+	} while (0)
-+
-+/*
-+ *  Thread defines
-+ */
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+#define DUK_HTHREAD_GET_STRING(thr,idx) \
-+	((duk_hstring *) DUK_USE_HEAPPTR_DEC16((thr)->heap->heap_udata, (thr)->strs16[(idx)]))
-+#else
-+#define DUK_HTHREAD_GET_STRING(thr,idx) \
-+	((thr)->strs[(idx)])
-+#endif
-+
-+#define DUK_HTHREAD_GET_CURRENT_ACTIVATION(thr)  (&(thr)->callstack[(thr)->callstack_top - 1])
-+
-+/* values for the state field */
-+#define DUK_HTHREAD_STATE_INACTIVE     1   /* thread not currently running */
-+#define DUK_HTHREAD_STATE_RUNNING      2   /* thread currently running (only one at a time) */
-+#define DUK_HTHREAD_STATE_RESUMED      3   /* thread resumed another thread (active but not running) */
-+#define DUK_HTHREAD_STATE_YIELDED      4   /* thread has yielded */
-+#define DUK_HTHREAD_STATE_TERMINATED   5   /* thread has terminated */
-+
-+/*
-+ *  Struct defines
-+ */
-+
-+/* XXX: for a memory-code tradeoff, remove 'func' and make it's access either a function
-+ * or a macro.  This would make the activation 32 bytes long on 32-bit platforms again.
-+ */
-+
-+/* Note: it's nice if size is 2^N (at least for 32-bit platforms). */
-+struct duk_activation {
-+	duk_tval tv_func;       /* borrowed: full duk_tval for function being executed; for lightfuncs */
-+	duk_hobject *func;      /* borrowed: function being executed; for bound function calls, this is the final, real function, NULL for lightfuncs */
-+	duk_hobject *var_env;   /* current variable environment (may be NULL if delayed) */
-+	duk_hobject *lex_env;   /* current lexical environment (may be NULL if delayed) */
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+	/* Previous value of 'func' caller, restored when unwound.  Only in use
-+	 * when 'func' is non-strict.
-+	 */
-+	duk_hobject *prev_caller;
-+#endif
-+
-+	duk_small_uint_t flags;
-+	duk_uint32_t pc;        /* next instruction to execute */
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	duk_uint32_t prev_line; /* needed for stepping */
-+#endif
-+
-+	/* idx_bottom and idx_retval are only used for book-keeping of
-+	 * Ecmascript-initiated calls, to allow returning to an Ecmascript
-+	 * function properly.  They are duk_size_t to match the convention
-+	 * that value stack sizes are duk_size_t and local frame indices
-+	 * are duk_idx_t.
-+	 */
-+
-+	/* Bottom of valstack for this activation, used to reset
-+	 * valstack_bottom on return; index is absolute.  Note:
-+	 * idx_top not needed because top is set to 'nregs' always
-+	 * when returning to an Ecmascript activation.
-+	 */
-+	duk_size_t idx_bottom;
-+
-+	/* Return value when returning to this activation (points to caller
-+	 * reg, not callee reg); index is absolute (only set if activation is
-+	 * not topmost).
-+	 *
-+	 * Note: idx_bottom is always set, while idx_retval is only applicable
-+	 * for activations below the topmost one.  Currently idx_retval for
-+	 * the topmost activation is considered garbage (and it not initialized
-+	 * on entry or cleared on return; may contain previous or garbage
-+	 * values).
-+	 */
-+	duk_size_t idx_retval;
-+
-+	/* Current 'this' binding is the value just below idx_bottom.
-+	 * Previously, 'this' binding was handled with an index to the
-+	 * (calling) valstack.  This works for everything except tail
-+	 * calls, which must not "cumulate" valstack temps.
-+	 */
-+};
-+
-+/* Note: it's nice if size is 2^N (not 4x4 = 16 bytes on 32 bit) */
-+struct duk_catcher {
-+	duk_hstring *h_varname;         /* borrowed reference to catch variable name (or NULL if none) */
-+	                                /* (reference is valid as long activation exists) */
-+	duk_size_t callstack_index;     /* callstack index of related activation */
-+	duk_size_t idx_base;            /* idx_base and idx_base+1 get completion value and type */
-+	duk_uint32_t pc_base;           /* resume execution from pc_base or pc_base+1 */
-+	duk_uint32_t flags;             /* type and control flags, label number */
-+};
-+
-+struct duk_hthread {
-+	/* shared object part */
-+	duk_hobject obj;
-+
-+	/* backpointers */
-+	duk_heap *heap;
-+
-+	/* current strictness flag: affects API calls */
-+	duk_uint8_t strict;
-+	duk_uint8_t state;
-+	duk_uint8_t unused1;
-+	duk_uint8_t unused2;
-+
-+	/* sanity limits */
-+	duk_size_t valstack_max;
-+	duk_size_t callstack_max;
-+	duk_size_t catchstack_max;
-+
-+	/* XXX: valstack, callstack, and catchstack are currently assumed
-+	 * to have non-NULL pointers.  Relaxing this would not lead to big
-+	 * benefits (except perhaps for terminated threads).
-+	 */
-+
-+	/* value stack: these are expressed as pointers for faster stack manipulation */
-+	duk_tval *valstack;                     /* start of valstack allocation */
-+	duk_tval *valstack_end;                 /* end of valstack allocation (exclusive) */
-+	duk_tval *valstack_bottom;              /* bottom of current frame */
-+	duk_tval *valstack_top;                 /* top of current frame (exclusive) */
-+
-+	/* call stack */
-+	duk_activation *callstack;
-+	duk_size_t callstack_size;              /* allocation size */
-+	duk_size_t callstack_top;               /* next to use, highest used is top - 1 */
-+	duk_size_t callstack_preventcount;      /* number of activation records in callstack preventing a yield */
-+
-+	/* catch stack */
-+	duk_catcher *catchstack;
-+	duk_size_t catchstack_size;             /* allocation size */
-+	duk_size_t catchstack_top;              /* next to use, highest used is top - 1 */
-+
-+	/* yield/resume book-keeping */
-+	duk_hthread *resumer;                   /* who resumed us (if any) */
-+
-+	/* current compiler state (if any), used for augmenting SyntaxErrors */
-+	duk_compiler_ctx *compile_ctx;
-+
-+#ifdef DUK_USE_INTERRUPT_COUNTER
-+	/* Interrupt counter for triggering a slow path check for execution
-+	 * timeout, debugger interaction such as breakpoints, etc.  This is
-+	 * actually a value copied from the heap structure into the current
-+	 * thread to be more convenient for the bytecode executor inner loop.
-+	 * The final value is copied back to the heap structure on a thread
-+	 * switch by DUK_HEAP_SWITCH_THREAD().
-+	 */
-+	duk_int_t interrupt_counter;
-+#endif
-+
-+	/* Builtin-objects; may or may not be shared with other threads,
-+	 * threads existing in different "compartments" will have different
-+	 * built-ins.  Must be stored on a per-thread basis because there
-+	 * is no intermediate structure for a thread group / compartment.
-+	 * This takes quite a lot of space, currently 43x4 = 172 bytes on
-+	 * 32-bit platforms.
-+	 */
-+	duk_hobject *builtins[DUK_NUM_BUILTINS];
-+
-+	/* convenience copies from heap/vm for faster access */
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t *strs16;
-+#else
-+	duk_hstring **strs;
-+#endif
-+};
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+DUK_INTERNAL_DECL void duk_hthread_copy_builtin_objects(duk_hthread *thr_from, duk_hthread *thr_to);
-+DUK_INTERNAL_DECL void duk_hthread_create_builtin_objects(duk_hthread *thr);
-+DUK_INTERNAL_DECL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_hthread_terminate(duk_hthread *thr);
-+
-+DUK_INTERNAL_DECL void duk_hthread_callstack_grow(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_hthread_callstack_shrink_check(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top);
-+DUK_INTERNAL_DECL void duk_hthread_catchstack_grow(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_hthread_catchstack_shrink_check(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top);
-+
-+DUK_INTERNAL_DECL duk_activation *duk_hthread_get_current_activation(duk_hthread *thr);
-+DUK_INTERNAL_DECL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud);  /* indirect allocs */
-+DUK_INTERNAL_DECL void *duk_hthread_get_callstack_ptr(duk_heap *heap, void *ud);  /* indirect allocs */
-+DUK_INTERNAL_DECL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud);  /* indirect allocs */
-+
-+#endif  /* DUK_HTHREAD_H_INCLUDED */
-+#line 1 "duk_hbuffer.h"
-+/*
-+ *  Heap buffer representation.
-+ *
-+ *  Heap allocated user data buffer which is either:
-+ *
-+ *    1. A fixed size buffer (data follows header statically)
-+ *    2. A dynamic size buffer (data pointer follows header)
-+ *
-+ *  The data pointer for a variable size buffer of zero size may be NULL.
-+ */
-+
-+#ifndef DUK_HBUFFER_H_INCLUDED
-+#define DUK_HBUFFER_H_INCLUDED
-+
-+/*
-+ *  Flags
-+ */
-+
-+#define DUK_HBUFFER_FLAG_DYNAMIC                  DUK_HEAPHDR_USER_FLAG(0)  /* buffer is resizable */
-+
-+#define DUK_HBUFFER_HAS_DYNAMIC(x)                DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-+
-+#define DUK_HBUFFER_SET_DYNAMIC(x)                DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-+
-+#define DUK_HBUFFER_CLEAR_DYNAMIC(x)              DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-+
-+#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap,x)    ((duk_uint8_t *) (((duk_hbuffer_fixed *) (x)) + 1))
-+
-+/*
-+ *  Misc defines
-+ */
-+
-+/* Impose a maximum buffer length for now.  Restricted artificially to
-+ * ensure resize computations or adding a heap header length won't
-+ * overflow size_t.  The limit should be synchronized with
-+ * DUK_HSTRING_MAX_BYTELEN.
-+ */
-+
-+#if defined(DUK_USE_BUFLEN16)
-+#define DUK_HBUFFER_MAX_BYTELEN                   (0x0000ffffUL)
-+#else
-+#define DUK_HBUFFER_MAX_BYTELEN                   (0x7fffffffUL)
-+#endif
-+
-+/*
-+ *  Field access
-+ */
-+
-+/* Get/set the current user visible size, without accounting for a dynamic
-+ * buffer's "spare" (= usable size).
-+ */
-+#if defined(DUK_USE_BUFLEN16)
-+/* size stored in duk_heaphdr unused flag bits */
-+#define DUK_HBUFFER_GET_SIZE(x)     ((x)->hdr.h_flags >> 16)
-+#define DUK_HBUFFER_SET_SIZE(x,v)   do { \
-+		(x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | ((v) << 16); \
-+	} while (0)
-+#define DUK_HBUFFER_ADD_SIZE(x,dv)  do { \
-+		(x)->hdr.h_flags += ((dv) << 16); \
-+	} while (0)
-+#define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
-+		(x)->hdr.h_flags -= ((dv) << 16); \
-+	} while (0)
-+#else
-+#define DUK_HBUFFER_GET_SIZE(x)     (((duk_hbuffer *) (x))->size)
-+#define DUK_HBUFFER_SET_SIZE(x,v)   do { \
-+		((duk_hbuffer *) (x))->size = (v); \
-+	} while (0)
-+#define DUK_HBUFFER_ADD_SIZE(x,dv)  do { \
-+		(x)->size += (dv); \
-+	} while (0)
-+#define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
-+		(x)->size -= (dv); \
-+	} while (0)
-+#endif
-+
-+#define DUK_HBUFFER_FIXED_GET_SIZE(x)       DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
-+#define DUK_HBUFFER_FIXED_SET_SIZE(x,v)     DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x))
-+
-+#define DUK_HBUFFER_DYNAMIC_GET_SIZE(x)     DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
-+#define DUK_HBUFFER_DYNAMIC_SET_SIZE(x,v)   DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
-+#define DUK_HBUFFER_DYNAMIC_ADD_SIZE(x,dv)  DUK_HBUFFER_ADD_SIZE((duk_hbuffer *) (x), (dv))
-+#define DUK_HBUFFER_DYNAMIC_SUB_SIZE(x,dv)  DUK_HBUFFER_SUB_SIZE((duk_hbuffer *) (x), (dv))
-+
-+#if defined(DUK_USE_BUFLEN16) && defined(DUK_USE_HEAPPTR16)
-+/* alloc_size16 stored in duk_heaphdr h_extra16, available with pointer compression. */
-+#define DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(x)    ((duk_size_t) ((x)->hdr.h_extra16))
-+#define DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(x,v)  do { \
-+		(x)->hdr.h_extra16 = (duk_uint16_t) (v); \
-+	} while (0)
-+#elif defined(DUK_USE_BUFLEN16)
-+/* alloc_size16 stored in an explicit 16-bit fields. */
-+#define DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(x)    ((duk_size_t) ((x)->alloc_size16))
-+#define DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(x,v)  do { \
-+		(x)->alloc_size16 = (duk_uint16_t) (v); \
-+	} while (0)
-+#else
-+/* normal case */
-+#define DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(x)    ((x)->alloc_size)
-+#define DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(x,v)  do { \
-+		(x)->alloc_size = (v); \
-+	} while (0)
-+#endif
-+
-+#define DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(x) \
-+	(duk_size_t) (DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE((x)) - DUK_HBUFFER_DYNAMIC_GET_SIZE((x)))
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x) \
-+	((void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (x)->curr_alloc16))
-+#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v)     do { \
-+		(x)->curr_alloc16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
-+	} while (0)
-+#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x)  do { \
-+		(x)->curr_alloc16 = 0;  /* assume 0 <=> NULL */ \
-+	} while (0)
-+#else
-+#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x)       ((x)->curr_alloc)
-+#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v)     do { \
-+		(x)->curr_alloc = (void *) (v); \
-+	} while (0)
-+#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x)  do { \
-+		(x)->curr_alloc = (void *) NULL; \
-+	} while (0)
-+#endif
-+
-+/* Gets the actual buffer contents which matches the current allocation size
-+ * (may be NULL for zero size dynamic buffer).
-+ */
-+#define DUK_HBUFFER_GET_DATA_PTR(heap,x)  ( \
-+	DUK_HBUFFER_HAS_DYNAMIC((x)) ? \
-+		DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) : \
-+		DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (x)) \
-+	)
-+
-+/* Growth parameters for dynamic buffers. */
-+#define DUK_HBUFFER_SPARE_ADD      16
-+#define DUK_HBUFFER_SPARE_DIVISOR  16   /* 2^4 -> 1/16 = 6.25% spare */
-+
-+/*
-+ *  Structs
-+ */
-+
-+struct duk_hbuffer {
-+	duk_heaphdr hdr;
-+
-+	/* It's not strictly necessary to track the current size, but
-+	 * it is useful for writing robust native code.
-+	 */
-+
-+	/* Current size (not counting a dynamic buffer's "spare"). */
-+#if defined(DUK_USE_BUFLEN16)
-+	/* Stored in duk_heaphdr unused flags. */
-+#else
-+	duk_size_t size;
-+#endif
-+
-+	/*
-+	 *  Data following the header depends on the DUK_HBUFFER_FLAG_DYNAMIC
-+	 *  flag.
-+	 *
-+	 *  If the flag is clear (the buffer is a fixed size one), the buffer
-+	 *  data follows the header directly, consisting of 'size' bytes.
-+	 *
-+	 *  If the flag is set, the actual buffer is allocated separately, and
-+	 *  a few control fields follow the header.  Specifically:
-+	 *
-+	 *    - a "void *" pointing to the current allocation
-+	 *    - a duk_size_t indicating the full allocated size (always >= 'size')
-+	 *
-+	 *  Unlike strings, no terminator byte (NUL) is guaranteed after the
-+	 *  data.  This would be convenient, but would pad aligned user buffers
-+	 *  unnecessarily upwards in size.  For instance, if user code requested
-+	 *  a 64-byte dynamic buffer, 65 bytes would actually be allocated which
-+	 *  would then potentially round upwards to perhaps 68 or 72 bytes.
-+	 */
-+};
-+
-+#if defined(DUK_USE_ALIGN_8) && defined(DUK_USE_PACK_MSVC_PRAGMA)
-+#pragma pack(push, 8)
-+#endif
-+struct duk_hbuffer_fixed {
-+	/* A union is used here as a portable struct size / alignment trick:
-+	 * by adding a 32-bit or a 64-bit (unused) union member, the size of
-+	 * the struct is effectively forced to be a multiple of 4 or 8 bytes
-+	 * (respectively) without increasing the size of the struct unless
-+	 * necessary.
-+	 */
-+	union {
-+		struct {
-+			duk_heaphdr hdr;
-+#if defined(DUK_USE_BUFLEN16)
-+			/* Stored in duk_heaphdr unused flags. */
-+#else
-+			duk_size_t size;
-+#endif
-+		} s;
-+#if defined(DUK_USE_ALIGN_4)
-+		duk_uint32_t dummy_for_align4;
-+#elif defined(DUK_USE_ALIGN_8)
-+		duk_double_t dummy_for_align8;
-+#else
-+		/* no extra padding */
-+#endif
-+	} u;
-+
-+	/*
-+	 *  Data follows the struct header.  The struct size is padded by the
-+	 *  compiler based on the struct members.  This guarantees that the
-+	 *  buffer data will be aligned-by-4 but not necessarily aligned-by-8.
-+	 *
-+	 *  On platforms where alignment does not matter, the struct padding
-+	 *  could be removed (if there is any).  On platforms where alignment
-+	 *  by 8 is required, the struct size must be forced to be a multiple
-+	 *  of 8 by some means.  Without it, some user code may break, and also
-+	 *  Duktape itself breaks (e.g. the compiler stores duk_tvals in a
-+	 *  dynamic buffer).
-+	 */
-+}
-+#if defined(DUK_USE_ALIGN_8) && defined(DUK_USE_PACK_GCC_ATTR)
-+__attribute__ ((aligned (8)))
-+#elif defined(DUK_USE_ALIGN_8) && defined(DUK_USE_PACK_CLANG_ATTR)
-+__attribute__ ((aligned (8)))
-+#endif
-+;
-+#if defined(DUK_USE_ALIGN_8) && defined(DUK_USE_PACK_MSVC_PRAGMA)
-+#pragma pack(pop)
-+#endif
-+
-+struct duk_hbuffer_dynamic {
-+	duk_heaphdr hdr;
-+
-+#if defined(DUK_USE_BUFLEN16)
-+	/* Stored in duk_heaphdr unused flags. */
-+#else
-+	duk_size_t size;
-+#endif
-+
-+#if defined(DUK_USE_BUFLEN16) && defined(DUK_USE_HEAPPTR16)
-+	/* Stored in duk_heaphdr h_extra16. */
-+#elif defined(DUK_USE_BUFLEN16)
-+	duk_uint16_t alloc_size16;
-+#else
-+	duk_size_t alloc_size;
-+#endif
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t curr_alloc16;
-+#else
-+	void *curr_alloc;  /* may be NULL if alloc_size == 0 */
-+#endif
-+
-+	/*
-+	 *  Allocation size for 'curr_alloc' is alloc_size.  There is no
-+	 *  automatic NUL terminator for buffers (see above for rationale).
-+	 *
-+	 *  'curr_alloc' is explicitly allocated with heap allocation
-+	 *  primitives and will thus always have alignment suitable for
-+	 *  e.g. duk_tval and an IEEE double.
-+	 */
-+};
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+DUK_INTERNAL_DECL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags);
-+DUK_INTERNAL_DECL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud);  /* indirect allocs */
-+
-+/* dynamic buffer ops */
-+DUK_INTERNAL_DECL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size, duk_size_t new_alloc_size);
-+DUK_INTERNAL_DECL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf);
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL void duk_hbuffer_compact(duk_hthread *thr, duk_hbuffer_dynamic *buf);
-+#endif
-+DUK_INTERNAL_DECL void duk_hbuffer_append_bytes(duk_hthread *thr, duk_hbuffer_dynamic *buf, const duk_uint8_t *data, duk_size_t length);
-+DUK_INTERNAL_DECL void duk_hbuffer_append_byte(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_uint8_t byte);
-+DUK_INTERNAL_DECL duk_size_t duk_hbuffer_append_cstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, const char *str);
-+DUK_INTERNAL_DECL duk_size_t duk_hbuffer_append_hstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_hstring *str);
-+DUK_INTERNAL_DECL duk_size_t duk_hbuffer_append_xutf8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_ucodepoint_t codepoint);
-+DUK_INTERNAL_DECL duk_size_t duk_hbuffer_append_cesu8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_ucodepoint_t codepoint);
-+#if 0
-+DUK_INTERNAL_DECL void duk_hbuffer_append_native_u32(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_uint32_t val);
-+#endif
-+DUK_INTERNAL_DECL void duk_hbuffer_insert_bytes(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, const duk_uint8_t *data, duk_size_t length);
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL void duk_hbuffer_insert_byte(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_uint8_t byte);
-+#endif
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL duk_size_t duk_hbuffer_insert_cstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, const char *str);
-+#endif
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL duk_size_t duk_hbuffer_insert_hstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_hstring *str);
-+#endif
-+DUK_INTERNAL_DECL duk_size_t duk_hbuffer_insert_xutf8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_ucodepoint_t codepoint);
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL duk_size_t duk_hbuffer_insert_cesu8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_ucodepoint_t codepoint);
-+#endif
-+DUK_INTERNAL_DECL void duk_hbuffer_remove_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_size_t length);
-+DUK_INTERNAL_DECL void duk_hbuffer_insert_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t dst_offset, duk_size_t src_offset, duk_size_t length);
-+DUK_INTERNAL_DECL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t src_offset, duk_size_t length);
-+
-+#endif  /* DUK_HBUFFER_H_INCLUDED */
-+#line 1 "duk_heap.h"
-+/*
-+ *  Heap structure.
-+ *
-+ *  Heap contains allocated heap objects, interned strings, and built-in
-+ *  strings for one or more threads.
-+ */
-+
-+#ifndef DUK_HEAP_H_INCLUDED
-+#define DUK_HEAP_H_INCLUDED
-+
-+/* alloc function typedefs in duktape.h */
-+
-+/*
-+ *  Heap flags
-+ */
-+
-+#define DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING                     (1 << 0)  /* mark-and-sweep is currently running */
-+#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED            (1 << 1)  /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */
-+#define DUK_HEAP_FLAG_REFZERO_FREE_RUNNING                     (1 << 2)  /* refcount code is processing refzero list */
-+#define DUK_HEAP_FLAG_ERRHANDLER_RUNNING                       (1 << 3)  /* an error handler (user callback to augment/replace error) is running */
-+#define DUK_HEAP_FLAG_INTERRUPT_RUNNING                        (1 << 4)  /* executor interrupt running (used to avoid nested interrupts) */
-+
-+#define DUK__HEAP_HAS_FLAGS(heap,bits)               ((heap)->flags & (bits))
-+#define DUK__HEAP_SET_FLAGS(heap,bits)  do { \
-+		(heap)->flags |= (bits); \
-+	} while (0)
-+#define DUK__HEAP_CLEAR_FLAGS(heap,bits)  do { \
-+		(heap)->flags &= ~(bits); \
-+	} while (0)
-+
-+#define DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)            DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)
-+#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
-+#define DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap)            DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)
-+#define DUK_HEAP_HAS_ERRHANDLER_RUNNING(heap)              DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)
-+#define DUK_HEAP_HAS_INTERRUPT_RUNNING(heap)               DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
-+
-+#define DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap)            DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)
-+#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
-+#define DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap)            DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)
-+#define DUK_HEAP_SET_ERRHANDLER_RUNNING(heap)              DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)
-+#define DUK_HEAP_SET_INTERRUPT_RUNNING(heap)               DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
-+
-+#define DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap)          DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RUNNING)
-+#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
-+#define DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap)          DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_REFZERO_FREE_RUNNING)
-+#define DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(heap)            DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_ERRHANDLER_RUNNING)
-+#define DUK_HEAP_CLEAR_INTERRUPT_RUNNING(heap)             DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
-+
-+/*
-+ *  Longjmp types, also double as identifying continuation type for a rethrow (in 'finally')
-+ */
-+
-+#define DUK_LJ_TYPE_UNKNOWN      0    /* unused */
-+#define DUK_LJ_TYPE_RETURN       1    /* value1 -> return value */
-+#define DUK_LJ_TYPE_THROW        2    /* value1 -> error object */
-+#define DUK_LJ_TYPE_BREAK        3    /* value1 -> label number */
-+#define DUK_LJ_TYPE_CONTINUE     4    /* value1 -> label number */
-+#define DUK_LJ_TYPE_YIELD        5    /* value1 -> yield value, iserror -> error / normal */
-+#define DUK_LJ_TYPE_RESUME       6    /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */
-+#define DUK_LJ_TYPE_NORMAL       7    /* pseudo-type to indicate a normal continuation (for 'finally' rethrowing) */
-+
-+/*
-+ *  Mark-and-sweep flags
-+ *
-+ *  These are separate from heap level flags now but could be merged.
-+ *  The heap structure only contains a 'base mark-and-sweep flags'
-+ *  field and the GC caller can impose further flags.
-+ */
-+
-+#define DUK_MS_FLAG_EMERGENCY                (1 << 0)   /* emergency mode: try extra hard */
-+#define DUK_MS_FLAG_NO_STRINGTABLE_RESIZE    (1 << 1)   /* don't resize stringtable (but may sweep it); needed during stringtable resize */
-+#define DUK_MS_FLAG_NO_FINALIZERS            (1 << 2)   /* don't run finalizers (which may have arbitrary side effects) */
-+#define DUK_MS_FLAG_NO_OBJECT_COMPACTION     (1 << 3)   /* don't compact objects; needed during object property allocation resize */
-+
-+/*
-+ *  Thread switching
-+ *
-+ *  To switch heap->curr_thread, use the macro below so that interrupt counters
-+ *  get updated correctly.  The macro allows a NULL target thread because that
-+ *  happens e.g. in call handling.
-+ */
-+
-+#if defined(DUK_USE_INTERRUPT_COUNTER)
-+#define DUK_HEAP_SWITCH_THREAD(heap,newthr)  duk_heap_switch_thread((heap), (newthr))
-+#else
-+#define DUK_HEAP_SWITCH_THREAD(heap,newthr)  do { \
-+		(heap)->curr_thread = (newthr); \
-+	} while (0)
-+#endif
-+
-+/*
-+ *  Other heap related defines
-+ */
-+
-+/* Maximum duk_handle_call / duk_handle_safe_call depth.  Note that this
-+ * does not limit bytecode executor internal call depth at all (e.g.
-+ * for Ecmascript-to-Ecmascript calls, thread yields/resumes, etc).
-+ * There is a separate callstack depth limit for threads.
-+ */
-+
-+#if defined(DUK_USE_DEEP_C_STACK)
-+#define DUK_HEAP_DEFAULT_CALL_RECURSION_LIMIT             1000  /* assuming 0.5 kB between calls, about 500kB of stack */
-+#else
-+#define DUK_HEAP_DEFAULT_CALL_RECURSION_LIMIT             60    /* assuming 0.5 kB between calls, about 30kB of stack */
-+#endif
-+
-+/* Mark-and-sweep C recursion depth for marking phase; if reached,
-+ * mark object as a TEMPROOT and use multi-pass marking.
-+ */
-+#if defined(DUK_USE_MARK_AND_SWEEP)
-+#if defined(DUK_USE_GC_TORTURE)
-+#define DUK_HEAP_MARK_AND_SWEEP_RECURSION_LIMIT   3
-+#elif defined(DUK_USE_DEEP_C_STACK)
-+#define DUK_HEAP_MARK_AND_SWEEP_RECURSION_LIMIT   256
-+#else
-+#define DUK_HEAP_MARK_AND_SWEEP_RECURSION_LIMIT   32
-+#endif
-+#endif
-+
-+/* Mark-and-sweep interval is relative to combined count of objects and
-+ * strings kept in the heap during the latest mark-and-sweep pass.
-+ * Fixed point .8 multiplier and .0 adder.  Trigger count (interval) is
-+ * decreased by each (re)allocation attempt (regardless of size), and each
-+ * refzero processed object.
-+ *
-+ * 'SKIP' indicates how many (re)allocations to wait until a retry if
-+ * GC is skipped because there is no thread do it with yet (happens
-+ * only during init phases).
-+ */
-+#if defined(DUK_USE_MARK_AND_SWEEP)
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT              12800L  /* 50x heap size */
-+#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD               1024L
-+#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP              256L
-+#else
-+#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT              256L    /* 1x heap size */
-+#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD               1024L
-+#define DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP              256L
-+#endif
-+#endif
-+
-+/* Stringcache is used for speeding up char-offset-to-byte-offset
-+ * translations for non-ASCII strings.
-+ */
-+#define DUK_HEAP_STRCACHE_SIZE                            4
-+#define DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT                16  /* strings up to the this length are not cached */
-+
-+/* helper to insert a (non-string) heap object into heap allocated list */
-+#define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap,hdr)     duk_heap_insert_into_heap_allocated((heap),(hdr))
-+
-+/* Executor interrupt default interval when nothing else requires a
-+ * smaller value.  The default interval must be small enough to allow
-+ * for reasonable execution timeout checking.
-+ */
-+#if defined(DUK_USE_INTERRUPT_COUNTER)
-+#define DUK_HEAP_INTCTR_DEFAULT                           (256L * 1024L)
-+#endif
-+
-+/*
-+ *  Stringtable
-+ */
-+
-+/* initial stringtable size, must be prime and higher than DUK_UTIL_MIN_HASH_PRIME */
-+#define DUK_STRTAB_INITIAL_SIZE            17
-+
-+/* indicates a deleted string; any fixed non-NULL, non-hstring pointer works */
-+#define DUK_STRTAB_DELETED_MARKER(heap)    ((duk_hstring *) heap)
-+
-+/* resizing parameters */
-+#define DUK_STRTAB_MIN_FREE_DIVISOR        4                /* load factor max 75% */
-+#define DUK_STRTAB_MIN_USED_DIVISOR        4                /* load factor min 25% */
-+#define DUK_STRTAB_GROW_ST_SIZE(n)         ((n) + (n))      /* used entries + approx 100% -> reset load to 50% */
-+
-+#define DUK_STRTAB_U32_MAX_STRLEN          10               /* 4'294'967'295 */
-+#define DUK_STRTAB_HIGHEST_32BIT_PRIME     0xfffffffbUL
-+
-+/* probe sequence (open addressing) */
-+#define DUK_STRTAB_HASH_INITIAL(hash,h_size)    ((hash) % (h_size))
-+#define DUK_STRTAB_HASH_PROBE_STEP(hash)        DUK_UTIL_GET_HASH_PROBE_STEP((hash))
-+
-+/* fixed top level hashtable size (separate chaining) */
-+#define DUK_STRTAB_CHAIN_SIZE              DUK_USE_STRTAB_CHAIN_SIZE
-+
-+/*
-+ *  Built-in strings
-+ */
-+
-+/* heap string indices are autogenerated in duk_strings.h */
-+#if defined(DUK_USE_HEAPPTR16)
-+#define DUK_HEAP_GET_STRING(heap,idx) \
-+	((duk_hstring *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (heap)->strs16[(idx)]))
-+#else
-+#define DUK_HEAP_GET_STRING(heap,idx) \
-+	((heap)->strs[(idx)])
-+#endif
-+
-+/*
-+ *  Raw memory calls: relative to heap, but no GC interaction
-+ */
-+
-+#define DUK_ALLOC_RAW(heap,size) \
-+	((heap)->alloc_func((heap)->heap_udata, (size)))
-+
-+#define DUK_REALLOC_RAW(heap,ptr,newsize) \
-+	((heap)->realloc_func((heap)->heap_udata, (void *) (ptr), (newsize)))
-+
-+#define DUK_FREE_RAW(heap,ptr) \
-+	((heap)->free_func((heap)->heap_udata, (void *) (ptr)))
-+
-+/*
-+ *  Memory calls: relative to heap, GC interaction, but no error throwing.
-+ *
-+ *  XXX: Currently a mark-and-sweep triggered by memory allocation will run
-+ *  using the heap->heap_thread.  This thread is also used for running
-+ *  mark-and-sweep finalization; this is not ideal because it breaks the
-+ *  isolation between multiple global environments.
-+ *
-+ *  Notes:
-+ *
-+ *    - DUK_FREE() is required to ignore NULL and any other possible return
-+ *      value of a zero-sized alloc/realloc (same as ANSI C free()).
-+ *
-+ *    - There is no DUK_REALLOC_ZEROED because we don't assume to know the
-+ *      old size.  Caller must zero the reallocated memory.
-+ *
-+ *    - DUK_REALLOC_INDIRECT() must be used when a mark-and-sweep triggered
-+ *      by an allocation failure might invalidate the original 'ptr', thus
-+ *      causing a realloc retry to use an invalid pointer.  Example: we're
-+ *      reallocating the value stack and a finalizer resizes the same value
-+ *      stack during mark-and-sweep.  The indirect variant requests for the
-+ *      current location of the pointer being reallocated using a callback
-+ *      right before every realloc attempt; this circuitous approach is used
-+ *      to avoid strict aliasing issues in a more straightforward indirect
-+ *      pointer (void **) approach.  Note: the pointer in the storage
-+ *      location is read but is NOT updated; the caller must do that.
-+ */
-+
-+/* callback for indirect reallocs, request for current pointer */
-+typedef void *(*duk_mem_getptr)(duk_heap *heap, void *ud);
-+
-+#define DUK_ALLOC(heap,size)                            duk_heap_mem_alloc((heap), (size))
-+#define DUK_ALLOC_ZEROED(heap,size)                     duk_heap_mem_alloc_zeroed((heap), (size))
-+#define DUK_REALLOC(heap,ptr,newsize)                   duk_heap_mem_realloc((heap), (ptr), (newsize))
-+#define DUK_REALLOC_INDIRECT(heap,cb,ud,newsize)        duk_heap_mem_realloc_indirect((heap), (cb), (ud), (newsize))
-+#define DUK_FREE(heap,ptr)                              duk_heap_mem_free((heap), (ptr))
-+
-+/*
-+ *  Memory constants
-+ */
-+
-+#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT           5   /* Retry allocation after mark-and-sweep for this
-+                                                              * many times.  A single mark-and-sweep round is
-+                                                              * not guaranteed to free all unreferenced memory
-+                                                              * because of finalization (in fact, ANY number of
-+                                                              * rounds is strictly not enough).
-+                                                              */
-+
-+#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT  3  /* Starting from this round, use emergency mode
-+                                                              * for mark-and-sweep.
-+                                                              */
-+
-+/*
-+ *  Debugger support
-+ */
-+
-+/* Maximum number of breakpoints.  Only breakpoints that are set are
-+ * consulted so increasing this has no performance impact.
-+ */
-+#define DUK_HEAP_MAX_BREAKPOINTS          16
-+
-+/* Opcode interval for a Date-based status/peek rate limit check.  Only
-+ * relevant when debugger is attached.  Requesting a timestamp may be a
-+ * slow operation on some platforms so this shouldn't be too low.  On the
-+ * other hand a high value makes Duktape react to a pause request slowly.
-+ */
-+#define DUK_HEAP_DBG_RATELIMIT_OPCODES    4000
-+
-+/* Milliseconds between status notify and transport peeks. */
-+#define DUK_HEAP_DBG_RATELIMIT_MILLISECS  200
-+
-+/* Step types */
-+#define DUK_STEP_TYPE_NONE  0
-+#define DUK_STEP_TYPE_INTO  1
-+#define DUK_STEP_TYPE_OVER  2
-+#define DUK_STEP_TYPE_OUT   3
-+
-+struct duk_breakpoint {
-+	duk_hstring *filename;
-+	duk_uint32_t line;
-+};
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+#define DUK_HEAP_IS_DEBUGGER_ATTACHED(heap) ((heap)->dbg_read_cb != NULL)
-+#define DUK_HEAP_CLEAR_STEP_STATE(heap) do { \
-+		(heap)->dbg_step_type = DUK_STEP_TYPE_NONE; \
-+		(heap)->dbg_step_thread = NULL; \
-+		(heap)->dbg_step_csindex = 0; \
-+		(heap)->dbg_step_startline = 0; \
-+	} while (0)
-+#define DUK_HEAP_SET_PAUSED(heap) do { \
-+		(heap)->dbg_paused = 1; \
-+		(heap)->dbg_state_dirty = 1; \
-+		DUK_HEAP_CLEAR_STEP_STATE((heap)); \
-+	} while (0)
-+#define DUK_HEAP_CLEAR_PAUSED(heap) do { \
-+		(heap)->dbg_paused = 0; \
-+		(heap)->dbg_state_dirty = 1; \
-+		DUK_HEAP_CLEAR_STEP_STATE((heap)); \
-+	} while (0)
-+#endif  /* DUK_USE_DEBUGGER_SUPPORT */
-+
-+/*
-+ *  String cache should ideally be at duk_hthread level, but that would
-+ *  cause string finalization to slow down relative to the number of
-+ *  threads; string finalization must check the string cache for "weak"
-+ *  references to the string being finalized to avoid dead pointers.
-+ *
-+ *  Thus, string caches are now at the heap level now.
-+ */
-+
-+struct duk_strcache {
-+	duk_hstring *h;
-+	duk_uint32_t bidx;
-+	duk_uint32_t cidx;
-+};
-+
-+/*
-+ *  Longjmp state, contains the information needed to perform a longjmp.
-+ *  Longjmp related values are written to value1, value2, and iserror.
-+ */
-+
-+struct duk_ljstate {
-+	duk_jmpbuf *jmpbuf_ptr;   /* current setjmp() catchpoint */
-+	duk_small_uint_t type;    /* longjmp type */
-+	duk_bool_t iserror;       /* isError flag for yield */
-+	duk_tval value1;          /* 1st related value (type specific) */
-+	duk_tval value2;          /* 2nd related value (type specific) */
-+};
-+
-+/*
-+ *  Stringtable entry for fixed size stringtable
-+ */
-+
-+struct duk_strtab_entry {
-+#if defined(DUK_USE_HEAPPTR16)
-+	/* A 16-bit listlen makes sense with 16-bit heap pointers: there
-+	 * won't be space for 64k strings anyway.
-+	 */
-+	duk_uint16_t listlen;  /* if 0, 'str16' used, if > 0, 'strlist16' used */
-+	union {
-+		duk_uint16_t strlist16;
-+		duk_uint16_t str16;
-+	} u;
-+#else
-+	duk_size_t listlen;  /* if 0, 'str' used, if > 0, 'strlist' used */
-+	union {
-+		duk_hstring **strlist;
-+		duk_hstring *str;
-+	} u;
-+#endif
-+};
-+
-+/*
-+ *  Main heap structure
-+ */
-+
-+struct duk_heap {
-+	duk_small_uint_t flags;
-+
-+	/* Allocator functions. */
-+	duk_alloc_function alloc_func;
-+	duk_realloc_function realloc_func;
-+	duk_free_function free_func;
-+
-+	/* Heap udata, used for allocator functions but also for other heap
-+	 * level callbacks like pointer compression, etc.
-+	 */
-+	void *heap_udata;
-+
-+	/* Precomputed pointers when using 16-bit heap pointer packing. */
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t heapptr_null16;
-+	duk_uint16_t heapptr_deleted16;
-+#endif
-+
-+	/* Fatal error handling, called e.g. when a longjmp() is needed but
-+	 * lj.jmpbuf_ptr is NULL.  fatal_func must never return; it's not
-+	 * declared as "noreturn" because doing that for typedefs is a bit
-+	 * challenging portability-wise.
-+	 */
-+	duk_fatal_function fatal_func;
-+
-+	/* allocated heap objects */
-+	duk_heaphdr *heap_allocated;
-+
-+	/* work list for objects whose refcounts are zero but which have not been
-+	 * "finalized"; avoids recursive C calls when refcounts go to zero in a
-+	 * chain of objects.
-+	 */
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+	duk_heaphdr *refzero_list;
-+	duk_heaphdr *refzero_list_tail;
-+#endif
-+
-+#if defined(DUK_USE_MARK_AND_SWEEP)
-+	/* mark-and-sweep control */
-+#if defined(DUK_USE_VOLUNTARY_GC)
-+	duk_int_t mark_and_sweep_trigger_counter;
-+#endif
-+	duk_int_t mark_and_sweep_recursion_depth;
-+
-+	/* mark-and-sweep flags automatically active (used for critical sections) */
-+	duk_small_uint_t mark_and_sweep_base_flags;
-+
-+	/* work list for objects to be finalized (by mark-and-sweep) */
-+	duk_heaphdr *finalize_list;
-+#endif
-+
-+	/* longjmp state */
-+	duk_ljstate lj;
-+
-+	/* marker for detecting internal "double faults", see duk_error_throw.c */
-+	duk_bool_t handling_error;
-+
-+	/* heap thread, used internally and for finalization */
-+	duk_hthread *heap_thread;
-+
-+	/* current thread */
-+	duk_hthread *curr_thread;  /* currently running thread */
-+
-+	/* heap level "stash" object (e.g., various reachability roots) */
-+	duk_hobject *heap_object;
-+
-+	/* heap level temporary log formatting buffer */
-+	duk_hbuffer_dynamic *log_buffer;
-+
-+	/* duk_handle_call / duk_handle_safe_call recursion depth limiting */
-+	duk_int_t call_recursion_depth;
-+	duk_int_t call_recursion_limit;
-+
-+	/* mix-in value for computing string hashes; should be reasonably unpredictable */
-+	duk_uint32_t hash_seed;
-+
-+	/* rnd_state for duk_util_tinyrandom.c */
-+	duk_uint32_t rnd_state;
-+
-+	/* interrupt counter */
-+#if defined(DUK_USE_INTERRUPT_COUNTER)
-+	duk_int_t interrupt_init;       /* start value for current countdown */
-+	duk_int_t interrupt_counter;    /* countdown state (mirrored in current thread state) */
-+#endif
-+
-+	/* debugger */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	/* callbacks and udata; dbg_read_cb != NULL is used to indicate attached state */
-+	duk_debug_read_function dbg_read_cb;                /* required, NULL implies detached */
-+	duk_debug_write_function dbg_write_cb;              /* required */
-+	duk_debug_peek_function dbg_peek_cb;
-+	duk_debug_read_flush_function dbg_read_flush_cb;
-+	duk_debug_write_flush_function dbg_write_flush_cb;
-+	duk_debug_detached_function dbg_detached_cb;
-+	void *dbg_udata;
-+
-+	/* debugger state, only relevant when attached */
-+	duk_bool_t dbg_processing;              /* currently processing messages or breakpoints: don't enter message processing recursively (e.g. no breakpoints when processing debugger eval) */
-+	duk_bool_t dbg_paused;                  /* currently paused: talk with debug client until step/resume */
-+	duk_bool_t dbg_state_dirty;             /* resend state next time executor is about to run */
-+	duk_small_uint_t dbg_step_type;         /* step type: none, step into, step over, step out */
-+	duk_hthread *dbg_step_thread;           /* borrowed; NULL if no step state (NULLed in unwind) */
-+	duk_size_t dbg_step_csindex;            /* callstack index */
-+	duk_uint32_t dbg_step_startline;        /* starting line number */
-+	duk_breakpoint dbg_breakpoints[DUK_HEAP_MAX_BREAKPOINTS];  /* breakpoints: [0,breakpoint_count[ gc reachable */
-+	duk_small_uint_t dbg_breakpoint_count;
-+	duk_breakpoint *dbg_breakpoints_active[DUK_HEAP_MAX_BREAKPOINTS + 1];  /* currently active breakpoints: NULL term, borrowed pointers */
-+	/* XXX: make active breakpoints actual copies instead of pointers? */
-+
-+	/* These are for rate limiting Status notifications and transport peeking. */
-+	duk_uint32_t dbg_exec_counter;          /* cumulative opcode execution count (overflows are OK) */
-+	duk_uint32_t dbg_last_counter;          /* value of dbg_exec_counter when we last did a Date-based check */
-+	duk_double_t dbg_last_time;             /* time when status/peek was last done (Date-based rate limit) */
-+#endif
-+
-+	/* string intern table (weak refs) */
-+#if defined(DUK_USE_STRTAB_PROBE)
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t *strtable16;
-+#else
-+	duk_hstring **strtable;
-+#endif
-+	duk_uint32_t st_size;     /* alloc size in elements */
-+	duk_uint32_t st_used;     /* used elements (includes DELETED) */
-+#endif
-+
-+	/* XXX: static alloc is OK until separate chaining stringtable
-+	 * resizing is implemented.
-+	 */
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	duk_strtab_entry strtable[DUK_STRTAB_CHAIN_SIZE];
-+#endif
-+
-+	/* string access cache (codepoint offset -> byte offset) for fast string
-+	 * character looping; 'weak' reference which needs special handling in GC.
-+	 */
-+	duk_strcache strcache[DUK_HEAP_STRCACHE_SIZE];
-+
-+	/* built-in strings */
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t strs16[DUK_HEAP_NUM_STRINGS];
-+#else
-+	duk_hstring *strs[DUK_HEAP_NUM_STRINGS];
-+#endif
-+};
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+DUK_INTERNAL_DECL
-+duk_heap *duk_heap_alloc(duk_alloc_function alloc_func,
-+                         duk_realloc_function realloc_func,
-+                         duk_free_function free_func,
-+                         void *heap_udata,
-+                         duk_fatal_function fatal_func);
-+DUK_INTERNAL_DECL void duk_heap_free(duk_heap *heap);
-+DUK_INTERNAL_DECL void duk_free_hobject_inner(duk_heap *heap, duk_hobject *h);
-+DUK_INTERNAL_DECL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h);
-+DUK_INTERNAL_DECL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h);
-+DUK_INTERNAL_DECL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr);
-+
-+DUK_INTERNAL_DECL void duk_heap_insert_into_heap_allocated(duk_heap *heap, duk_heaphdr *hdr);
-+#if defined(DUK_USE_DOUBLE_LINKED_HEAP) && defined(DUK_USE_REFERENCE_COUNTING)
-+DUK_INTERNAL_DECL void duk_heap_remove_any_from_heap_allocated(duk_heap *heap, duk_heaphdr *hdr);
-+#endif
-+#if defined(DUK_USE_INTERRUPT_COUNTER)
-+DUK_INTERNAL_DECL void duk_heap_switch_thread(duk_heap *heap, duk_hthread *new_thr);
-+#endif
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen);
-+#endif
-+DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen);
-+DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t len);
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL duk_hstring *duk_heap_string_lookup_u32(duk_heap *heap, duk_uint32_t val);
-+#endif
-+DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val);
-+DUK_INTERNAL_DECL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val);
-+DUK_INTERNAL_DECL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h);
-+#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE)
-+DUK_INTERNAL_DECL void duk_heap_force_strtab_resize(duk_heap *heap);
-+#endif
-+DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap);
-+#if defined(DUK_USE_DEBUG)
-+DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap);
-+#endif
-+
-+
-+DUK_INTERNAL_DECL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h);
-+DUK_INTERNAL_DECL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *thr, duk_hstring *h, duk_uint_fast32_t char_offset);
-+
-+#if defined(DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS)
-+DUK_INTERNAL_DECL void *duk_default_alloc_function(void *udata, duk_size_t size);
-+DUK_INTERNAL_DECL void *duk_default_realloc_function(void *udata, void *ptr, duk_size_t newsize);
-+DUK_INTERNAL_DECL void duk_default_free_function(void *udata, void *ptr);
-+#endif
-+
-+DUK_INTERNAL_DECL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size);
-+DUK_INTERNAL_DECL void *duk_heap_mem_alloc_zeroed(duk_heap *heap, duk_size_t size);
-+DUK_INTERNAL_DECL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize);
-+DUK_INTERNAL_DECL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize);
-+DUK_INTERNAL_DECL void duk_heap_mem_free(duk_heap *heap, void *ptr);
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
-+DUK_INTERNAL_DECL void duk_tval_incref(duk_tval *tv);
-+#endif
-+#if 0  /* unused */
-+DUK_INTERNAL_DECL void duk_tval_incref_allownull(duk_tval *tv);
-+#endif
-+DUK_INTERNAL_DECL void duk_tval_decref(duk_hthread *thr, duk_tval *tv);
-+#if 0  /* unused */
-+DUK_INTERNAL_DECL void duk_tval_decref_allownull(duk_hthread *thr, duk_tval *tv);
-+#endif
-+#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
-+DUK_INTERNAL_DECL void duk_heaphdr_incref(duk_heaphdr *h);
-+#endif
-+#if 0  /* unused */
-+DUK_INTERNAL_DECL void duk_heaphdr_incref_allownull(duk_heaphdr *h);
-+#endif
-+DUK_INTERNAL_DECL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h);
-+DUK_INTERNAL_DECL void duk_heaphdr_decref_allownull(duk_hthread *thr, duk_heaphdr *h);
-+DUK_INTERNAL_DECL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h);
-+DUK_INTERNAL_DECL void duk_heaphdr_refcount_finalize(duk_hthread *thr, duk_heaphdr *hdr);
-+#else
-+/* no refcounting */
-+#endif
-+
-+#if defined(DUK_USE_MARK_AND_SWEEP)
-+DUK_INTERNAL_DECL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t flags);
-+#endif
-+
-+DUK_INTERNAL_DECL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len);
-+
-+#endif  /* DUK_HEAP_H_INCLUDED */
-+#line 1 "duk_debugger.h"
-+#ifndef DUK_DEBUGGER_H_INCLUDED
-+#define DUK_DEBUGGER_H_INCLUDED
-+
-+/* Debugger protocol version is defined in the public API header. */
-+
-+#define DUK_DBG_MARKER_EOM        0x00
-+#define DUK_DBG_MARKER_REQUEST    0x01
-+#define DUK_DBG_MARKER_REPLY      0x02
-+#define DUK_DBG_MARKER_ERROR      0x03
-+#define DUK_DBG_MARKER_NOTIFY     0x04
-+
-+#define DUK_DBG_ERR_UNKNOWN       0x00
-+#define DUK_DBG_ERR_UNSUPPORTED   0x01
-+#define DUK_DBG_ERR_TOOMANY       0x02
-+#define DUK_DBG_ERR_NOTFOUND      0x03
-+
-+/* Initiated by Duktape */
-+#define DUK_DBG_CMD_STATUS        0x01
-+#define DUK_DBG_CMD_PRINT         0x02
-+#define DUK_DBG_CMD_ALERT         0x03
-+#define DUK_DBG_CMD_LOG           0x04
-+
-+/* Initiated by debug client */
-+#define DUK_DBG_CMD_BASICINFO     0x10
-+#define DUK_DBG_CMD_TRIGGERSTATUS 0x11
-+#define DUK_DBG_CMD_PAUSE         0x12
-+#define DUK_DBG_CMD_RESUME        0x13
-+#define DUK_DBG_CMD_STEPINTO      0x14
-+#define DUK_DBG_CMD_STEPOVER      0x15
-+#define DUK_DBG_CMD_STEPOUT       0x16
-+#define DUK_DBG_CMD_LISTBREAK     0x17
-+#define DUK_DBG_CMD_ADDBREAK      0x18
-+#define DUK_DBG_CMD_DELBREAK      0x19
-+#define DUK_DBG_CMD_GETVAR        0x1a
-+#define DUK_DBG_CMD_PUTVAR        0x1b
-+#define DUK_DBG_CMD_GETCALLSTACK  0x1c
-+#define DUK_DBG_CMD_GETLOCALS     0x1d
-+#define DUK_DBG_CMD_EVAL          0x1e
-+#define DUK_DBG_CMD_DETACH        0x1f
-+#define DUK_DBG_CMD_DUMPHEAP      0x20
-+#define DUK_DBG_CMD_GETBYTECODE   0x21
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+DUK_INTERNAL_DECL void duk_debug_do_detach(duk_heap *heap);
-+
-+DUK_INTERNAL_DECL duk_bool_t duk_debug_read_peek(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_debug_write_flush(duk_hthread *thr);
-+
-+DUK_INTERNAL_DECL void duk_debug_skip_bytes(duk_hthread *thr, duk_size_t length);
-+DUK_INTERNAL_DECL void duk_debug_skip_byte(duk_hthread *thr);
-+
-+DUK_INTERNAL_DECL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_size_t length);
-+DUK_INTERNAL_DECL duk_uint8_t duk_debug_read_byte(duk_hthread *thr);
-+DUK_INTERNAL_DECL duk_int32_t duk_debug_read_int(duk_hthread *thr);
-+DUK_INTERNAL_DECL duk_hstring *duk_debug_read_hstring(duk_hthread *thr);
-+/* XXX: exposed duk_debug_read_pointer */
-+/* XXX: exposed duk_debug_read_buffer */
-+/* XXX: exposed duk_debug_read_hbuffer */
-+DUK_INTERNAL_DECL void duk_debug_read_tval(duk_hthread *thr);
-+
-+DUK_INTERNAL_DECL void duk_debug_write_bytes(duk_hthread *thr, const duk_uint8_t *data, duk_size_t length);
-+DUK_INTERNAL_DECL void duk_debug_write_byte(duk_hthread *thr, duk_uint8_t x);
-+DUK_INTERNAL_DECL void duk_debug_write_unused(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_debug_write_undefined(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_debug_write_int(duk_hthread *thr, duk_int32_t x);
-+DUK_INTERNAL_DECL void duk_debug_write_uint(duk_hthread *thr, duk_uint32_t x);
-+DUK_INTERNAL_DECL void duk_debug_write_string(duk_hthread *thr, const char *data, duk_size_t length);
-+DUK_INTERNAL_DECL void duk_debug_write_cstring(duk_hthread *thr, const char *data);
-+DUK_INTERNAL_DECL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h);
-+DUK_INTERNAL_DECL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length);
-+DUK_INTERNAL_DECL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h);
-+DUK_INTERNAL_DECL void duk_debug_write_pointer(duk_hthread *thr, const void *ptr);
-+#if defined(DUK_USE_DEBUGGER_DUMPHEAP)
-+DUK_INTERNAL_DECL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h);
-+#endif
-+DUK_INTERNAL_DECL void duk_debug_write_hobject(duk_hthread *thr, duk_hobject *obj);
-+DUK_INTERNAL_DECL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv);
-+
-+#if 0  /* unused */
-+DUK_INTERNAL_DECL void duk_debug_write_request(duk_hthread *thr, duk_small_uint_t command);
-+#endif
-+DUK_INTERNAL_DECL void duk_debug_write_reply(duk_hthread *thr);
-+DUK_INTERNAL_DECL void duk_debug_write_error_eom(duk_hthread *thr, duk_small_uint_t err_code, const char *msg);
-+DUK_INTERNAL_DECL void duk_debug_write_notify(duk_hthread *thr, duk_small_uint_t command);
-+DUK_INTERNAL_DECL void duk_debug_write_eom(duk_hthread *thr);
-+
-+DUK_INTERNAL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr);
-+DUK_INTERNAL void duk_debug_send_status(duk_hthread *thr);
-+
-+DUK_INTERNAL_DECL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t no_block);
-+
-+DUK_INTERNAL_DECL duk_small_int_t duk_debug_add_breakpoint(duk_hthread *thr, duk_hstring *filename, duk_uint32_t line);
-+DUK_INTERNAL_DECL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_uint_t breakpoint_index);
-+#endif
-+
-+#endif  /* DUK_DEBUGGER_H_INCLUDED */
-+#line 1 "duk_debug.h"
-+/*
-+ *  Debugging macros, DUK_DPRINT() and its variants in particular.
-+ *
-+ *  DUK_DPRINT() allows formatted debug prints, and supports standard
-+ *  and Duktape specific formatters.  See duk_debug_vsnprintf.c for details.
-+ *
-+ *  DUK_D(x), DUK_DD(x), and DUK_DDD(x) are used together with log macros
-+ *  for technical reasons.  They are concretely used to hide 'x' from the
-+ *  compiler when the corresponding log level is disabled.  This allows
-+ *  clean builds on non-C99 compilers, at the cost of more verbose code.
-+ *  Examples:
-+ *
-+ *    DUK_D(DUK_DPRINT("foo"));
-+ *    DUK_DD(DUK_DDPRINT("foo"));
-+ *    DUK_DDD(DUK_DDDPRINT("foo"));
-+ *
-+ *  This approach is preferable to the old "double parentheses" hack because
-+ *  double parentheses make the C99 solution worse: __FILE__ and __LINE__ can
-+ *  no longer be added transparently without going through globals, which
-+ *  works poorly with threading.
-+ */
-+
-+#ifndef DUK_DEBUG_H_INCLUDED
-+#define DUK_DEBUG_H_INCLUDED
-+
-+#ifdef DUK_USE_DEBUG
-+
-+#if defined(DUK_USE_DPRINT)
-+#define DUK_D(x) x
-+#else
-+#define DUK_D(x) do { } while (0) /* omit */
-+#endif
-+
-+#if defined(DUK_USE_DDPRINT)
-+#define DUK_DD(x) x
-+#else
-+#define DUK_DD(x) do { } while (0) /* omit */
-+#endif
-+
-+#if defined(DUK_USE_DDDPRINT)
-+#define DUK_DDD(x) x
-+#else
-+#define DUK_DDD(x) do { } while (0) /* omit */
-+#endif
-+
-+/*
-+ *  Exposed debug macros: debugging enabled
-+ */
-+
-+#define DUK_LEVEL_DEBUG    1
-+#define DUK_LEVEL_DDEBUG   2
-+#define DUK_LEVEL_DDDEBUG  3
-+
-+#ifdef DUK_USE_VARIADIC_MACROS
-+
-+/* Note: combining __FILE__, __LINE__, and __func__ into fmt would be
-+ * possible compile time, but waste some space with shared function names.
-+ */
-+#define DUK__DEBUG_LOG(lev,...)  duk_debug_log((duk_small_int_t) (lev), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, DUK_FUNC_MACRO, __VA_ARGS__);
-+
-+#define DUK_DPRINT(...)          DUK__DEBUG_LOG(DUK_LEVEL_DEBUG, __VA_ARGS__)
-+
-+#ifdef DUK_USE_DDPRINT
-+#define DUK_DDPRINT(...)         DUK__DEBUG_LOG(DUK_LEVEL_DDEBUG, __VA_ARGS__)
-+#else
-+#define DUK_DDPRINT(...)
-+#endif
-+
-+#ifdef DUK_USE_DDDPRINT
-+#define DUK_DDDPRINT(...)        DUK__DEBUG_LOG(DUK_LEVEL_DDDEBUG, __VA_ARGS__)
-+#else
-+#define DUK_DDDPRINT(...)
-+#endif
-+
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+
-+#define DUK__DEBUG_STASH(lev)    \
-+	(void) DUK_SNPRINTF(duk_debug_file_stash, DUK_DEBUG_STASH_SIZE, "%s", (const char *) DUK_FILE_MACRO), \
-+	duk_debug_file_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0; \
-+	(void) DUK_SNPRINTF(duk_debug_line_stash, DUK_DEBUG_STASH_SIZE, "%ld", (long) DUK_LINE_MACRO), \
-+	duk_debug_line_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0; \
-+	(void) DUK_SNPRINTF(duk_debug_func_stash, DUK_DEBUG_STASH_SIZE, "%s", (const char *) DUK_FUNC_MACRO), \
-+	duk_debug_func_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0; \
-+	(void) (duk_debug_level_stash = (lev))
-+
-+/* Without variadic macros resort to comma expression trickery to handle debug
-+ * prints.  This generates a lot of harmless warnings.  These hacks are not
-+ * needed normally because DUK_D() and friends will hide the entire debug log
-+ * statement from the compiler.
-+ */
-+
-+#ifdef DUK_USE_DPRINT
-+#define DUK_DPRINT  DUK__DEBUG_STASH(DUK_LEVEL_DEBUG), (void) duk_debug_log  /* args go here in parens */
-+#else
-+#define DUK_DPRINT  0 && /* args go here as a comma expression in parens */
-+#endif
-+
-+#ifdef DUK_USE_DDPRINT
-+#define DUK_DDPRINT  DUK__DEBUG_STASH(DUK_LEVEL_DDEBUG), (void) duk_debug_log  /* args go here in parens */
-+#else
-+#define DUK_DDPRINT  0 && /* args */
-+#endif
-+
-+#ifdef DUK_USE_DDDPRINT
-+#define DUK_DDDPRINT  DUK__DEBUG_STASH(DUK_LEVEL_DDDEBUG), (void) duk_debug_log  /* args go here in parens */
-+#else
-+#define DUK_DDDPRINT  0 && /* args */
-+#endif
-+
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+#else  /* DUK_USE_DEBUG */
-+
-+/*
-+ *  Exposed debug macros: debugging disabled
-+ */
-+
-+#define DUK_D(x) do { } while (0) /* omit */
-+#define DUK_DD(x) do { } while (0) /* omit */
-+#define DUK_DDD(x) do { } while (0) /* omit */
-+
-+#ifdef DUK_USE_VARIADIC_MACROS
-+
-+#define DUK_DPRINT(...)
-+#define DUK_DDPRINT(...)
-+#define DUK_DDDPRINT(...)
-+
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+
-+#define DUK_DPRINT    0 && /* args go here as a comma expression in parens */
-+#define DUK_DDPRINT   0 && /* args */
-+#define DUK_DDDPRINT  0 && /* args */
-+
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+#endif  /* DUK_USE_DEBUG */
-+
-+/*
-+ *  Structs
-+ */
-+
-+#ifdef DUK_USE_DEBUG
-+struct duk_fixedbuffer {
-+	duk_uint8_t *buffer;
-+	duk_size_t length;
-+	duk_size_t offset;
-+	duk_bool_t truncated;
-+};
-+#endif
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+#ifdef DUK_USE_DEBUG
-+DUK_INTERNAL_DECL duk_int_t duk_debug_vsnprintf(char *str, duk_size_t size, const char *format, va_list ap);
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL duk_int_t duk_debug_snprintf(char *str, duk_size_t size, const char *format, ...);
-+#endif
-+DUK_INTERNAL_DECL void duk_debug_format_funcptr(char *buf, duk_size_t buf_size, duk_uint8_t *fptr, duk_size_t fptr_size);
-+
-+#ifdef DUK_USE_VARIADIC_MACROS
-+DUK_INTERNAL_DECL void duk_debug_log(duk_small_int_t level, const char *file, duk_int_t line, const char *func, const char *fmt, ...);
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+/* parameter passing, not thread safe */
-+#define DUK_DEBUG_STASH_SIZE  128
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL char duk_debug_file_stash[DUK_DEBUG_STASH_SIZE];
-+DUK_INTERNAL_DECL char duk_debug_line_stash[DUK_DEBUG_STASH_SIZE];
-+DUK_INTERNAL_DECL char duk_debug_func_stash[DUK_DEBUG_STASH_SIZE];
-+DUK_INTERNAL_DECL duk_small_int_t duk_debug_level_stash;
-+#endif
-+DUK_INTERNAL_DECL void duk_debug_log(const char *fmt, ...);
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+DUK_INTERNAL_DECL void duk_fb_put_bytes(duk_fixedbuffer *fb, duk_uint8_t *buffer, duk_size_t length);
-+DUK_INTERNAL_DECL void duk_fb_put_byte(duk_fixedbuffer *fb, duk_uint8_t x);
-+DUK_INTERNAL_DECL void duk_fb_put_cstring(duk_fixedbuffer *fb, const char *x);
-+DUK_INTERNAL_DECL void duk_fb_sprintf(duk_fixedbuffer *fb, const char *fmt, ...);
-+DUK_INTERNAL_DECL void duk_fb_put_funcptr(duk_fixedbuffer *fb, duk_uint8_t *fptr, duk_size_t fptr_size);
-+DUK_INTERNAL_DECL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb);
-+
-+#endif  /* DUK_USE_DEBUG */
-+
-+#endif  /* DUK_DEBUG_H_INCLUDED */
-+#line 1 "duk_error.h"
-+/*
-+ *  Error handling macros, assertion macro, error codes.
-+ *
-+ *  There are three level of 'errors':
-+ *
-+ *    1. Ordinary errors, relative to a thread, cause a longjmp, catchable.
-+ *    2. Fatal errors, relative to a heap, cause fatal handler to be called.
-+ *    3. Panic errors, unrelated to a heap and cause a process exit.
-+ *
-+ *  Panics are used by the default fatal error handler and by debug code
-+ *  such as assertions.  By providing a proper fatal error handler, user
-+ *  code can avoid panics in non-debug builds.
-+ */
-+
-+#ifndef DUK_ERROR_H_INCLUDED
-+#define DUK_ERROR_H_INCLUDED
-+
-+/*
-+ *  Error codes: defined in duktape.h
-+ *
-+ *  Error codes are used as a shorthand to throw exceptions from inside
-+ *  the implementation.  The appropriate Ecmascript object is constructed
-+ *  based on the code.  Ecmascript code throws objects directly.  The error
-+ *  codes are defined in the public API header because they are also used
-+ *  by calling code.
-+ */
-+
-+/*
-+ *  Normal error
-+ *
-+ *  Normal error is thrown with a longjmp() through the current setjmp()
-+ *  catchpoint record in the duk_heap.  The 'curr_thread' of the duk_heap
-+ *  identifies the throwing thread.
-+ *
-+ *  Error formatting is not always necessary but there are no separate calls
-+ *  (to minimize code size).  Error object creation will consume a considerable
-+ *  amount of time, compared to which formatting is probably trivial.  Note
-+ *  that special formatting (provided by DUK_DEBUG macros) is NOT available.
-+ *
-+ *  The _RAW variants allow the caller to specify file and line.  This makes
-+ *  it easier to write checked calls which want to use the call site of the
-+ *  checked function, not the error macro call inside the checked function.
-+ *
-+ *  We prefer the standard variadic macros; if they are not available, we
-+ *  fall back to awkward hacks.
-+ */
-+
-+#ifdef DUK_USE_VERBOSE_ERRORS
-+
-+#ifdef DUK_USE_VARIADIC_MACROS
-+
-+/* __VA_ARGS__ has comma issues for empty lists, so we mandate at least 1 argument for '...' (format string) */
-+#define DUK_ERROR(thr,err,...)                    duk_err_handle_error(DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (thr), (err), __VA_ARGS__)
-+#define DUK_ERROR_RAW(file,line,thr,err,...)      duk_err_handle_error((file), (line), (thr), (err), __VA_ARGS__)
-+
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+
-+/* Parameter passing here is not thread safe.  We rely on the __FILE__
-+ * pointer being a constant which can be passed through a global.
-+ */
-+
-+#define DUK_ERROR  \
-+	(void) (duk_err_file_stash = (const char *) DUK_FILE_MACRO, \
-+	        duk_err_line_stash = (duk_int_t) DUK_LINE_MACRO, \
-+	        duk_err_handle_error_stash)  /* arguments follow */
-+#define DUK_ERROR_RAW                             duk_err_handle_error
-+
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+#else  /* DUK_USE_VERBOSE_ERRORS */
-+
-+#ifdef DUK_USE_VARIADIC_MACROS
-+
-+#define DUK_ERROR(thr,err,...)                    duk_err_handle_error((thr), (err))
-+#define DUK_ERROR_RAW(file,line,thr,err,...)      duk_err_handle_error((thr), (err))
-+
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+
-+/* This is sub-optimal because arguments will be passed but ignored, and the strings
-+ * will go into the object file.  Can't think of how to do this portably and still
-+ * relatively conveniently.
-+ */
-+#define DUK_ERROR                                 duk_err_handle_error_nonverbose1
-+#define DUK_ERROR_RAW                             duk_err_handle_error_nonverbose2
-+
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+#endif  /* DUK_USE_VERBOSE_ERRORS */
-+
-+/*
-+ *  Fatal error
-+ *
-+ *  There are no fatal error macros at the moment.  There are so few call
-+ *  sites that the fatal error handler is called directly.
-+ */
-+
-+/*
-+ *  Panic error
-+ *
-+ *  Panic errors are not relative to either a heap or a thread, and cause
-+ *  DUK_PANIC() macro to be invoked.  Unlesa a user provides DUK_OPT_PANIC_HANDLER,
-+ *  DUK_PANIC() calls a helper which prints out the error and causes a process
-+ *  exit.
-+ *
-+ *  The user can override the macro to provide custom handling.  A macro is
-+ *  used to allow the user to have inline panic handling if desired (without
-+ *  causing a potentially risky function call).
-+ *
-+ *  Panics are only used in debug code such as assertions, and by the default
-+ *  fatal error handler.
-+ */
-+
-+#if defined(DUK_USE_PANIC_HANDLER)
-+/* already defined, good */
-+#define DUK_PANIC(code,msg)  DUK_USE_PANIC_HANDLER((code),(msg))
-+#else
-+#define DUK_PANIC(code,msg)  duk_default_panic_handler((code),(msg))
-+#endif  /* DUK_USE_PANIC_HANDLER */
-+
-+/*
-+ *  Assert macro: failure causes panic.
-+ */
-+
-+#ifdef DUK_USE_ASSERTIONS
-+
-+/* the message should be a compile time constant without formatting (less risk);
-+ * we don't care about assertion text size because they're not used in production
-+ * builds.
-+ */
-+#define DUK_ASSERT(x)  do { \
-+	if (!(x)) { \
-+		DUK_PANIC(DUK_ERR_ASSERTION_ERROR, \
-+			"assertion failed: " #x \
-+			" (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"); \
-+	} \
-+	} while (0)
-+
-+#else  /* DUK_USE_ASSERTIONS */
-+
-+#define DUK_ASSERT(x)  do { /* assertion omitted */ } while(0)
-+
-+#endif  /* DUK_USE_ASSERTIONS */
-+
-+/* this variant is used when an assert would generate a compile warning by
-+ * being always true (e.g. >= 0 comparison for an unsigned value
-+ */
-+#define DUK_ASSERT_DISABLE(x)  do { /* assertion disabled */ } while(0)
-+
-+/*
-+ *  Assertion helpers
-+ */
-+
-+#if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_REFERENCE_COUNTING)
-+#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h)  do { \
-+		DUK_ASSERT((h) == NULL || DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) (h)) > 0); \
-+	} while (0)
-+#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv)  do { \
-+		if ((tv) != NULL && DUK_TVAL_IS_HEAP_ALLOCATED((tv))) { \
-+			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(DUK_TVAL_GET_HEAPHDR((tv))) > 0); \
-+		} \
-+	} while (0)
-+#else
-+#define DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(h)  /* no refcount check */
-+#define DUK_ASSERT_REFCOUNT_NONZERO_TVAL(tv)    /* no refcount check */
-+#endif
-+
-+#define DUK_ASSERT_TOP(ctx,n)  DUK_ASSERT((duk_idx_t) duk_get_top((ctx)) == (duk_idx_t) (n))
-+
-+#if defined(DUK_USE_ASSERTIONS) && defined(DUK_USE_PACKED_TVAL)
-+#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval)  do { \
-+		duk_double_union assert_tmp_du; \
-+		assert_tmp_du.d = (dval); \
-+		DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&assert_tmp_du)); \
-+	} while (0)
-+#else
-+#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval)  /* nop */
-+#endif
-+
-+/*
-+ *  Helper for valstack space
-+ *
-+ *  Caller of DUK_ASSERT_VALSTACK_SPACE() estimates the number of free stack entries
-+ *  required for its own use, and any child calls which are not (a) Duktape API calls
-+ *  or (b) Duktape calls which involve extending the valstack (e.g. getter call).
-+ */
-+
-+#define DUK_VALSTACK_ASSERT_EXTRA  5  /* this is added to checks to allow for Duktape
-+                                       * API calls in addition to function's own use
-+                                       */
-+#if defined(DUK_USE_ASSERTIONS)
-+#define DUK_ASSERT_VALSTACK_SPACE(thr,n)   do { \
-+		DUK_ASSERT((thr) != NULL); \
-+		DUK_ASSERT((thr)->valstack_end - (thr)->valstack_top >= (n) + DUK_VALSTACK_ASSERT_EXTRA); \
-+	} while (0)
-+#else
-+#define DUK_ASSERT_VALSTACK_SPACE(thr,n)   /* no valstack space check */
-+#endif
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+#ifdef DUK_USE_VERBOSE_ERRORS
-+#ifdef DUK_USE_VARIADIC_MACROS
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...));
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL const char *duk_err_file_stash;
-+DUK_INTERNAL_DECL duk_int_t duk_err_line_stash;
-+#endif  /* !DUK_SINGLE_FILE */
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...));
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_stash(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...));
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+#else  /* DUK_USE_VERBOSE_ERRORS */
-+#ifdef DUK_USE_VARIADIC_MACROS
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code));
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_nonverbose1(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...));
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_nonverbose2(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...));
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+#endif  /* DUK_USE_VERBOSE_ERRORS */
-+
-+#ifdef DUK_USE_VERBOSE_ERRORS
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line));
-+#else
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code));
-+#endif
-+
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc));
-+
-+#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
-+DUK_INTERNAL_DECL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *filename, duk_int_t line, duk_bool_t noblame_fileline);
-+#endif
-+#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-+DUK_INTERNAL_DECL void duk_err_augment_error_throw(duk_hthread *thr);
-+#endif
-+
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_longjmp(duk_hthread *thr));
-+
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg));
-+
-+#if !defined(DUK_USE_PANIC_HANDLER)
-+DUK_NORETURN(DUK_INTERNAL_DECL void duk_default_panic_handler(duk_errcode_t code, const char *msg));
-+#endif
-+
-+DUK_INTERNAL_DECL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type);
-+
-+DUK_INTERNAL_DECL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t err_code);
-+
-+#endif  /* DUK_ERROR_H_INCLUDED */
-+#line 1 "duk_util.h"
-+/*
-+ *  Utilities
-+ */
-+
-+#ifndef DUK_UTIL_H_INCLUDED
-+#define DUK_UTIL_H_INCLUDED
-+
-+#define DUK_UTIL_MIN_HASH_PRIME  17  /* must match genhashsizes.py */
-+
-+#define DUK_UTIL_GET_HASH_PROBE_STEP(hash)  (duk_util_probe_steps[(hash) & 0x1f])
-+
-+/*
-+ *  Bitstream decoder
-+ */
-+
-+struct duk_bitdecoder_ctx {
-+	const duk_uint8_t *data;
-+	duk_size_t offset;
-+	duk_size_t length;
-+	duk_uint32_t currval;
-+	duk_small_int_t currbits;
-+};
-+
-+/*
-+ *  Bitstream encoder
-+ */
-+
-+struct duk_bitencoder_ctx {
-+	duk_uint8_t *data;
-+	duk_size_t offset;
-+	duk_size_t length;
-+	duk_uint32_t currval;
-+	duk_small_int_t currbits;
-+	duk_small_int_t truncated;
-+};
-+
-+/*
-+ *  Externs and prototypes
-+ */
-+
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL duk_uint8_t duk_lc_digits[36];
-+DUK_INTERNAL_DECL duk_uint8_t duk_uc_nybbles[16];
-+DUK_INTERNAL_DECL duk_int8_t duk_hex_dectab[256];
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+/* Note: assumes that duk_util_probe_steps size is 32 */
-+#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE)
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL duk_uint8_t duk_util_probe_steps[32];
-+#endif  /* !DUK_SINGLE_FILE */
-+#endif
-+
-+DUK_INTERNAL_DECL duk_uint32_t duk_util_hashbytes(const duk_uint8_t *data, duk_size_t len, duk_uint32_t seed);
-+
-+#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE)
-+DUK_INTERNAL_DECL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size);
-+#endif
-+
-+DUK_INTERNAL_DECL duk_int32_t duk_bd_decode(duk_bitdecoder_ctx *ctx, duk_small_int_t bits);
-+DUK_INTERNAL_DECL duk_small_int_t duk_bd_decode_flag(duk_bitdecoder_ctx *ctx);
-+DUK_INTERNAL_DECL duk_int32_t duk_bd_decode_flagged(duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value);
-+
-+DUK_INTERNAL_DECL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits);
-+DUK_INTERNAL_DECL void duk_be_finish(duk_bitencoder_ctx *ctx);
-+
-+DUK_INTERNAL_DECL duk_uint32_t duk_util_tinyrandom_get_bits(duk_hthread *thr, duk_small_int_t n);
-+DUK_INTERNAL_DECL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr);
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)  /* For now only needed by the debugger. */
-+DUK_INTERNAL void duk_byteswap_bytes(duk_uint8_t *p, duk_small_uint_t len);
-+#endif
-+
-+#endif  /* DUK_UTIL_H_INCLUDED */
-+#line 1 "duk_unicode.h"
-+/*
-+ *  Unicode helpers
-+ */
-+
-+#ifndef DUK_UNICODE_H_INCLUDED
-+#define DUK_UNICODE_H_INCLUDED
-+
-+/*
-+ *  UTF-8 / XUTF-8 / CESU-8 constants
-+ */
-+
-+#define DUK_UNICODE_MAX_XUTF8_LENGTH   7   /* up to 36 bit codepoints */
-+#define DUK_UNICODE_MAX_CESU8_LENGTH   6   /* all codepoints up to U+10FFFF */
-+
-+/*
-+ *  Useful Unicode codepoints
-+ *
-+ *  Integer constants must be signed to avoid unexpected coercions
-+ *  in comparisons.
-+ */
-+
-+#define DUK_UNICODE_CP_ZWNJ                   0x200cL  /* zero-width non-joiner */
-+#define DUK_UNICODE_CP_ZWJ                    0x200dL  /* zero-width joiner */
-+#define DUK_UNICODE_CP_REPLACEMENT_CHARACTER  0xfffdL  /* http://en.wikipedia.org/wiki/Replacement_character#Replacement_character */
-+
-+/*
-+ *  ASCII character constants
-+ *
-+ *  C character literals like 'x' have a platform specific value and do
-+ *  not match ASCII (UTF-8) values on e.g. EBCDIC platforms.  So, use
-+ *  these (admittedly awkward) constants instead.  These constants must
-+ *  also have signed values to avoid unexpected coercions in comparisons.
-+ *
-+ *  http://en.wikipedia.org/wiki/ASCII
-+ */
-+
-+#define DUK_ASC_NUL              0x00
-+#define DUK_ASC_SOH              0x01
-+#define DUK_ASC_STX              0x02
-+#define DUK_ASC_ETX              0x03
-+#define DUK_ASC_EOT              0x04
-+#define DUK_ASC_ENQ              0x05
-+#define DUK_ASC_ACK              0x06
-+#define DUK_ASC_BEL              0x07
-+#define DUK_ASC_BS               0x08
-+#define DUK_ASC_HT               0x09
-+#define DUK_ASC_LF               0x0a
-+#define DUK_ASC_VT               0x0b
-+#define DUK_ASC_FF               0x0c
-+#define DUK_ASC_CR               0x0d
-+#define DUK_ASC_SO               0x0e
-+#define DUK_ASC_SI               0x0f
-+#define DUK_ASC_DLE              0x10
-+#define DUK_ASC_DC1              0x11
-+#define DUK_ASC_DC2              0x12
-+#define DUK_ASC_DC3              0x13
-+#define DUK_ASC_DC4              0x14
-+#define DUK_ASC_NAK              0x15
-+#define DUK_ASC_SYN              0x16
-+#define DUK_ASC_ETB              0x17
-+#define DUK_ASC_CAN              0x18
-+#define DUK_ASC_EM               0x19
-+#define DUK_ASC_SUB              0x1a
-+#define DUK_ASC_ESC              0x1b
-+#define DUK_ASC_FS               0x1c
-+#define DUK_ASC_GS               0x1d
-+#define DUK_ASC_RS               0x1e
-+#define DUK_ASC_US               0x1f
-+#define DUK_ASC_SPACE            0x20
-+#define DUK_ASC_EXCLAMATION      0x21
-+#define DUK_ASC_DOUBLEQUOTE      0x22
-+#define DUK_ASC_HASH             0x23
-+#define DUK_ASC_DOLLAR           0x24
-+#define DUK_ASC_PERCENT          0x25
-+#define DUK_ASC_AMP              0x26
-+#define DUK_ASC_SINGLEQUOTE      0x27
-+#define DUK_ASC_LPAREN           0x28
-+#define DUK_ASC_RPAREN           0x29
-+#define DUK_ASC_STAR             0x2a
-+#define DUK_ASC_PLUS             0x2b
-+#define DUK_ASC_COMMA            0x2c
-+#define DUK_ASC_MINUS            0x2d
-+#define DUK_ASC_PERIOD           0x2e
-+#define DUK_ASC_SLASH            0x2f
-+#define DUK_ASC_0                0x30
-+#define DUK_ASC_1                0x31
-+#define DUK_ASC_2                0x32
-+#define DUK_ASC_3                0x33
-+#define DUK_ASC_4                0x34
-+#define DUK_ASC_5                0x35
-+#define DUK_ASC_6                0x36
-+#define DUK_ASC_7                0x37
-+#define DUK_ASC_8                0x38
-+#define DUK_ASC_9                0x39
-+#define DUK_ASC_COLON            0x3a
-+#define DUK_ASC_SEMICOLON        0x3b
-+#define DUK_ASC_LANGLE           0x3c
-+#define DUK_ASC_EQUALS           0x3d
-+#define DUK_ASC_RANGLE           0x3e
-+#define DUK_ASC_QUESTION         0x3f
-+#define DUK_ASC_ATSIGN           0x40
-+#define DUK_ASC_UC_A             0x41
-+#define DUK_ASC_UC_B             0x42
-+#define DUK_ASC_UC_C             0x43
-+#define DUK_ASC_UC_D             0x44
-+#define DUK_ASC_UC_E             0x45
-+#define DUK_ASC_UC_F             0x46
-+#define DUK_ASC_UC_G             0x47
-+#define DUK_ASC_UC_H             0x48
-+#define DUK_ASC_UC_I             0x49
-+#define DUK_ASC_UC_J             0x4a
-+#define DUK_ASC_UC_K             0x4b
-+#define DUK_ASC_UC_L             0x4c
-+#define DUK_ASC_UC_M             0x4d
-+#define DUK_ASC_UC_N             0x4e
-+#define DUK_ASC_UC_O             0x4f
-+#define DUK_ASC_UC_P             0x50
-+#define DUK_ASC_UC_Q             0x51
-+#define DUK_ASC_UC_R             0x52
-+#define DUK_ASC_UC_S             0x53
-+#define DUK_ASC_UC_T             0x54
-+#define DUK_ASC_UC_U             0x55
-+#define DUK_ASC_UC_V             0x56
-+#define DUK_ASC_UC_W             0x57
-+#define DUK_ASC_UC_X             0x58
-+#define DUK_ASC_UC_Y             0x59
-+#define DUK_ASC_UC_Z             0x5a
-+#define DUK_ASC_LBRACKET         0x5b
-+#define DUK_ASC_BACKSLASH        0x5c
-+#define DUK_ASC_RBRACKET         0x5d
-+#define DUK_ASC_CARET            0x5e
-+#define DUK_ASC_UNDERSCORE       0x5f
-+#define DUK_ASC_GRAVE            0x60
-+#define DUK_ASC_LC_A             0x61
-+#define DUK_ASC_LC_B             0x62
-+#define DUK_ASC_LC_C             0x63
-+#define DUK_ASC_LC_D             0x64
-+#define DUK_ASC_LC_E             0x65
-+#define DUK_ASC_LC_F             0x66
-+#define DUK_ASC_LC_G             0x67
-+#define DUK_ASC_LC_H             0x68
-+#define DUK_ASC_LC_I             0x69
-+#define DUK_ASC_LC_J             0x6a
-+#define DUK_ASC_LC_K             0x6b
-+#define DUK_ASC_LC_L             0x6c
-+#define DUK_ASC_LC_M             0x6d
-+#define DUK_ASC_LC_N             0x6e
-+#define DUK_ASC_LC_O             0x6f
-+#define DUK_ASC_LC_P             0x70
-+#define DUK_ASC_LC_Q             0x71
-+#define DUK_ASC_LC_R             0x72
-+#define DUK_ASC_LC_S             0x73
-+#define DUK_ASC_LC_T             0x74
-+#define DUK_ASC_LC_U             0x75
-+#define DUK_ASC_LC_V             0x76
-+#define DUK_ASC_LC_W             0x77
-+#define DUK_ASC_LC_X             0x78
-+#define DUK_ASC_LC_Y             0x79
-+#define DUK_ASC_LC_Z             0x7a
-+#define DUK_ASC_LCURLY           0x7b
-+#define DUK_ASC_PIPE             0x7c
-+#define DUK_ASC_RCURLY           0x7d
-+#define DUK_ASC_TILDE            0x7e
-+#define DUK_ASC_DEL              0x7f
-+
-+/*
-+ *  Unicode tables
-+ */
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+extern const duk_uint8_t duk_unicode_ids_noa[791];
-+#else
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+extern const duk_uint8_t duk_unicode_ids_noabmp[611];
-+#endif
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+extern const duk_uint8_t duk_unicode_ids_m_let_noa[42];
-+#else
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+extern const duk_uint8_t duk_unicode_ids_m_let_noabmp[24];
-+#endif
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+extern const duk_uint8_t duk_unicode_idp_m_ids_noa[397];
-+#else
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+extern const duk_uint8_t duk_unicode_idp_m_ids_noabmp[348];
-+#endif
-+
-+/*
-+ *  Automatically generated by extract_caseconv.py, do not edit!
-+ */
-+
-+extern const duk_uint8_t duk_unicode_caseconv_uc[1288];
-+extern const duk_uint8_t duk_unicode_caseconv_lc[616];
-+
-+/*
-+ *  Extern
-+ */
-+
-+/* duk_unicode_support.c */
-+#if !defined(DUK_SINGLE_FILE)
-+DUK_INTERNAL_DECL duk_uint8_t duk_unicode_xutf8_markers[7];
-+DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_digit[2];
-+DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_white[22];
-+DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_wordchar[8];
-+DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_not_digit[4];
-+DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_not_white[24];
-+DUK_INTERNAL_DECL duk_uint16_t duk_unicode_re_ranges_not_wordchar[10];
-+#endif  /* !DUK_SINGLE_FILE */
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_decode_xutf8(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_ucodepoint_t *out_cp);
-+DUK_INTERNAL_DECL duk_ucodepoint_t duk_unicode_decode_xutf8_checked(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end);
-+DUK_INTERNAL_DECL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_whitespace(duk_codepoint_t cp);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_line_terminator(duk_codepoint_t cp);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_start(duk_codepoint_t cp);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_identifier_part(duk_codepoint_t cp);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp);
-+DUK_INTERNAL_DECL void duk_unicode_case_convert_string(duk_hthread *thr, duk_bool_t uppercase);
-+DUK_INTERNAL_DECL duk_codepoint_t duk_unicode_re_canonicalize_char(duk_hthread *thr, duk_codepoint_t cp);
-+DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar(duk_codepoint_t cp);
-+
-+#endif  /* DUK_UNICODE_H_INCLUDED */
-+#line 1 "duk_json.h"
-+/*
-+ *  Defines for JSON, especially duk_bi_json.c.
-+ */
-+
-+#ifndef DUK_JSON_H_INCLUDED
-+#define DUK_JSON_H_INCLUDED
-+
-+/* Object/array recursion limit (to protect C stack) */
-+#if defined(DUK_USE_DEEP_C_STACK)
-+#define DUK_JSON_ENC_RECURSION_LIMIT          1000
-+#define DUK_JSON_DEC_RECURSION_LIMIT          1000
-+#else
-+#define DUK_JSON_ENC_RECURSION_LIMIT          100
-+#define DUK_JSON_DEC_RECURSION_LIMIT          100
-+#endif
-+
-+/* Encoding/decoding flags */
-+#define DUK_JSON_FLAG_ASCII_ONLY          (1 << 0)  /* escape any non-ASCII characters */
-+#define DUK_JSON_FLAG_AVOID_KEY_QUOTES    (1 << 1)  /* avoid key quotes when key is an ASCII Identifier */
-+#define DUK_JSON_FLAG_EXT_CUSTOM          (1 << 2)  /* extended types: custom encoding */
-+#define DUK_JSON_FLAG_EXT_COMPATIBLE      (1 << 3)  /* extended types: compatible encoding */
-+
-+/* How much stack to require on entry to object/array encode */
-+#define DUK_JSON_ENC_REQSTACK                 32
-+
-+/* How much stack to require on entry to object/array decode */
-+#define DUK_JSON_DEC_REQSTACK                 32
-+
-+/* Encoding state.  Heap object references are all borrowed. */
-+typedef struct {
-+	duk_hthread *thr;
-+	duk_hbuffer_dynamic *h_buf;
-+	duk_hobject *h_replacer;     /* replacer function */
-+	duk_hstring *h_gap;          /* gap (if empty string, NULL) */
-+	duk_hstring *h_indent;       /* current indent (if gap is NULL, this is NULL) */
-+	duk_idx_t idx_proplist;      /* explicit PropertyList */
-+	duk_idx_t idx_loop;          /* valstack index of loop detection object */
-+	duk_small_uint_t flags;
-+	duk_small_uint_t flag_ascii_only;
-+	duk_small_uint_t flag_avoid_key_quotes;
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+	duk_small_uint_t flag_ext_custom;
-+	duk_small_uint_t flag_ext_compatible;
-+#endif
-+	duk_int_t recursion_depth;
-+	duk_int_t recursion_limit;
-+	duk_uint_t mask_for_undefined;      /* type bit mask: types which certainly produce 'undefined' */
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+	duk_small_uint_t stridx_custom_undefined;
-+	duk_small_uint_t stridx_custom_nan;
-+	duk_small_uint_t stridx_custom_neginf;
-+	duk_small_uint_t stridx_custom_posinf;
-+	duk_small_uint_t stridx_custom_function;
-+#endif
-+} duk_json_enc_ctx;
-+
-+typedef struct {
-+	duk_hthread *thr;
-+	const duk_uint8_t *p;
-+	const duk_uint8_t *p_start;
-+	const duk_uint8_t *p_end;
-+	duk_idx_t idx_reviver;
-+	duk_small_uint_t flags;
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+	duk_small_uint_t flag_ext_custom;
-+	duk_small_uint_t flag_ext_compatible;
-+#endif
-+	duk_int_t recursion_depth;
-+	duk_int_t recursion_limit;
-+} duk_json_dec_ctx;
-+
-+#endif  /* DUK_JSON_H_INCLUDED */
-+#line 1 "duk_js.h"
-+/*
-+ *  Ecmascript execution, support primitives.
-+ */
-+
-+#ifndef DUK_JS_H_INCLUDED
-+#define DUK_JS_H_INCLUDED
-+
-+/* Flags for call handling. */
-+#define DUK_CALL_FLAG_PROTECTED              (1 << 0)  /* duk_handle_call: call is protected */
-+#define DUK_CALL_FLAG_IGNORE_RECLIMIT        (1 << 1)  /* duk_handle_call: call ignores C recursion limit (for errhandler calls) */
-+#define DUK_CALL_FLAG_CONSTRUCTOR_CALL       (1 << 2)  /* duk_handle_call: constructor call (i.e. called as 'new Foo()') */
-+#define DUK_CALL_FLAG_IS_RESUME              (1 << 3)  /* duk_handle_ecma_call_setup: setup for a resume() */
-+#define DUK_CALL_FLAG_IS_TAILCALL            (1 << 4)  /* duk_handle_ecma_call_setup: setup for a tailcall */
-+#define DUK_CALL_FLAG_DIRECT_EVAL            (1 << 5)  /* call is a direct eval call */
-+
-+/* Flags for duk_js_equals_helper(). */
-+#define DUK_EQUALS_FLAG_SAMEVALUE            (1 << 0)  /* use SameValue instead of non-strict equality */
-+#define DUK_EQUALS_FLAG_STRICT               (1 << 1)  /* use strict equality instead of non-strict equality */
-+
-+/* Flags for duk_js_compare_helper(). */
-+#define DUK_COMPARE_FLAG_EVAL_LEFT_FIRST     (1 << 0)  /* eval left argument first */
-+#define DUK_COMPARE_FLAG_NEGATE              (1 << 1)  /* negate result */
-+
-+/* conversions, coercions, comparison, etc */
-+DUK_INTERNAL_DECL duk_bool_t duk_js_toboolean(duk_tval *tv);
-+DUK_INTERNAL_DECL duk_double_t duk_js_tonumber(duk_hthread *thr, duk_tval *tv);
-+DUK_INTERNAL_DECL duk_double_t duk_js_tointeger_number(duk_double_t x);
-+DUK_INTERNAL_DECL duk_double_t duk_js_tointeger(duk_hthread *thr, duk_tval *tv);
-+DUK_INTERNAL_DECL duk_uint32_t duk_js_touint32(duk_hthread *thr, duk_tval *tv);
-+DUK_INTERNAL_DECL duk_int32_t duk_js_toint32(duk_hthread *thr, duk_tval *tv);
-+DUK_INTERNAL_DECL duk_uint16_t duk_js_touint16(duk_hthread *thr, duk_tval *tv);
-+DUK_INTERNAL_DECL duk_small_int_t duk_js_to_arrayindex_raw_string(const duk_uint8_t *str, duk_uint32_t blen, duk_uarridx_t *out_idx);
-+DUK_INTERNAL_DECL duk_uarridx_t duk_js_to_arrayindex_string_helper(duk_hstring *h);
-+DUK_INTERNAL_DECL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags);
-+DUK_INTERNAL_DECL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2);
-+DUK_INTERNAL_DECL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags);
-+DUK_INTERNAL_DECL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y);
-+DUK_INTERNAL_DECL duk_bool_t duk_js_in(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y);
-+DUK_INTERNAL_DECL duk_hstring *duk_js_typeof(duk_hthread *thr, duk_tval *tv_x);
-+
-+#define duk_js_equals(thr,tv_x,tv_y) \
-+	duk_js_equals_helper((thr), (tv_x), (tv_y), 0)
-+#define duk_js_strict_equals(tv_x,tv_y) \
-+	duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_STRICT)
-+#define duk_js_samevalue(tv_x,tv_y) \
-+	duk_js_equals_helper(NULL, (tv_x), (tv_y), DUK_EQUALS_FLAG_SAMEVALUE)
-+
-+/* E5 Sections 11.8.1, 11.8.5; x < y */
-+#define duk_js_lessthan(thr,tv_x,tv_y) \
-+	duk_js_compare_helper((thr), (tv_x), (tv_Y), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST)
-+
-+/* E5 Sections 11.8.2, 11.8.5; x > y  -->  y < x */
-+#define duk_js_greaterthan(thr,tv_x,tv_y) \
-+	duk_js_compare_helper((thr), (tv_y), (tv_x), 0)
-+
-+/* E5 Sections 11.8.3, 11.8.5; x <= y  -->  not (x > y)  -->  not (y < x) */
-+#define duk_js_lessthanorequal(thr,tv_x,tv_y) \
-+	duk_js_compare_helper((thr), (tv_y), (tv_x), DUK_COMPARE_FLAG_NEGATE)
-+
-+/* E5 Sections 11.8.4, 11.8.5; x >= y  -->  not (x < y) */
-+#define duk_js_greaterthanorequal(thr,tv_x,tv_y) \
-+	duk_js_compare_helper((thr), (tv_x), (tv_y), DUK_COMPARE_FLAG_EVAL_LEFT_FIRST | DUK_COMPARE_FLAG_NEGATE)
-+
-+/* identifiers and environment handling */
-+#if 0  /*unused*/
-+DUK_INTERNAL duk_bool_t duk_js_hasvar_envrec(duk_hthread *thr, duk_hobject *env, duk_hstring *name);
-+#endif
-+DUK_INTERNAL_DECL duk_bool_t duk_js_getvar_envrec(duk_hthread *thr, duk_hobject *env, duk_hstring *name, duk_bool_t throw_flag);
-+DUK_INTERNAL_DECL duk_bool_t duk_js_getvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name, duk_bool_t throw_flag);
-+DUK_INTERNAL_DECL void duk_js_putvar_envrec(duk_hthread *thr, duk_hobject *env, duk_hstring *name, duk_tval *val, duk_bool_t strict);
-+DUK_INTERNAL_DECL void duk_js_putvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name, duk_tval *val, duk_bool_t strict);
-+#if 0  /*unused*/
-+DUK_INTERNAL_DECL duk_bool_t duk_js_delvar_envrec(duk_hthread *thr, duk_hobject *env, duk_hstring *name);
-+#endif
-+DUK_INTERNAL_DECL duk_bool_t duk_js_delvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name);
-+DUK_INTERNAL_DECL duk_bool_t duk_js_declvar_activation(duk_hthread *thr, duk_activation *act, duk_hstring *name, duk_tval *val, duk_small_int_t prop_flags, duk_bool_t is_func_decl);
-+DUK_INTERNAL_DECL void duk_js_init_activation_environment_records_delayed(duk_hthread *thr, duk_activation *act);
-+DUK_INTERNAL_DECL void duk_js_close_environment_record(duk_hthread *thr, duk_hobject *env, duk_hobject *func, duk_size_t regbase);
-+DUK_INTERNAL_DECL duk_hobject *duk_create_activation_environment_record(duk_hthread *thr, duk_hobject *func, duk_size_t idx_bottom);
-+DUK_INTERNAL_DECL
-+void duk_js_push_closure(duk_hthread *thr,
-+                         duk_hcompiledfunction *fun_temp,
-+                         duk_hobject *outer_var_env,
-+                         duk_hobject *outer_lex_env);
-+
-+/* call handling */
-+DUK_INTERNAL_DECL duk_int_t duk_handle_call(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags);
-+DUK_INTERNAL_DECL duk_int_t duk_handle_safe_call(duk_hthread *thr, duk_safe_call_function func, duk_idx_t num_stack_args, duk_idx_t num_stack_res);
-+DUK_INTERNAL_DECL duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr, duk_idx_t num_stack_args, duk_small_uint_t call_flags);
-+
-+/* bytecode execution */
-+DUK_INTERNAL_DECL void duk_js_execute_bytecode(duk_hthread *exec_thr);
-+
-+#endif  /* DUK_JS_H_INCLUDED */
-+#line 1 "duk_numconv.h"
-+#ifndef DUK_NUMCONV_H_INCLUDED
-+#define DUK_NUMCONV_H_INCLUDED
-+
-+/*
-+ *  Number-to-string conversion.  The semantics of these is very tightly
-+ *  bound with the Ecmascript semantics required for call sites.
-+ */
-+
-+/* Output a specified number of digits instead of using the shortest
-+ * form.  Used for toPrecision() and toFixed().
-+ */
-+#define DUK_N2S_FLAG_FIXED_FORMAT         (1 << 0)
-+
-+/* Force exponential format.  Used for toExponential(). */
-+#define DUK_N2S_FLAG_FORCE_EXP            (1 << 1)
-+
-+/* If number would need zero padding (for whole number part), use
-+ * exponential format instead.  E.g. if input number is 12300, 3
-+ * digits are generated ("123"), output "1.23e+4" instead of "12300".
-+ * Used for toPrecision().
-+ */
-+#define DUK_N2S_FLAG_NO_ZERO_PAD          (1 << 2)
-+
-+/* Digit count indicates number of fractions (i.e. an absolute
-+ * digit index instead of a relative one).  Used together with
-+ * DUK_N2S_FLAG_FIXED_FORMAT for toFixed().
-+ */
-+#define DUK_N2S_FLAG_FRACTION_DIGITS      (1 << 3)
-+
-+/*
-+ *  String-to-number conversion
-+ */
-+
-+/* Maximum exponent value when parsing numbers.  This is not strictly
-+ * compliant as there should be no upper limit, but as we parse the
-+ * exponent without a bigint, impose some limit.
-+ */
-+#define DUK_S2N_MAX_EXPONENT              1000000000
-+
-+/* Trim white space (= allow leading and trailing whitespace) */
-+#define DUK_S2N_FLAG_TRIM_WHITE           (1 << 0)
-+
-+/* Allow exponent */
-+#define DUK_S2N_FLAG_ALLOW_EXP            (1 << 1)
-+
-+/* Allow trailing garbage (e.g. treat "123foo" as "123) */
-+#define DUK_S2N_FLAG_ALLOW_GARBAGE        (1 << 2)
-+
-+/* Allow leading plus sign */
-+#define DUK_S2N_FLAG_ALLOW_PLUS           (1 << 3)
-+
-+/* Allow leading minus sign */
-+#define DUK_S2N_FLAG_ALLOW_MINUS          (1 << 4)
-+
-+/* Allow 'Infinity' */
-+#define DUK_S2N_FLAG_ALLOW_INF            (1 << 5)
-+
-+/* Allow fraction part */
-+#define DUK_S2N_FLAG_ALLOW_FRAC           (1 << 6)
-+
-+/* Allow naked fraction (e.g. ".123") */
-+#define DUK_S2N_FLAG_ALLOW_NAKED_FRAC     (1 << 7)
-+
-+/* Allow empty fraction (e.g. "123.") */
-+#define DUK_S2N_FLAG_ALLOW_EMPTY_FRAC     (1 << 8)
-+
-+/* Allow empty string to be interpreted as 0 */
-+#define DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO  (1 << 9)
-+
-+/* Allow leading zeroes (e.g. "0123" -> "123") */
-+#define DUK_S2N_FLAG_ALLOW_LEADING_ZERO   (1 << 10)
-+
-+/* Allow automatic detection of hex base ("0x" or "0X" prefix),
-+ * overrides radix argument and forces integer mode.
-+ */
-+#define DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT   (1 << 11)
-+
-+/* Allow automatic detection of octal base, overrides radix
-+ * argument and forces integer mode.
-+ */
-+#define DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT   (1 << 12)
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+DUK_INTERNAL_DECL void duk_numconv_stringify(duk_context *ctx, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags);
-+DUK_INTERNAL_DECL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix, duk_small_uint_t flags);
-+
-+#endif  /* DUK_NUMCONV_H_INCLUDED */
-+#line 1 "duk_bi_protos.h"
-+/*
-+ *  Prototypes for all built-in functions.
-+ */
-+
-+#ifndef DUK_BUILTIN_PROTOS_H_INCLUDED
-+#define DUK_BUILTIN_PROTOS_H_INCLUDED
-+
-+/* Buffer size needed for duk_bi_date_format_timeval().
-+ * Accurate value is 32 + 1 for NUL termination:
-+ *   >>> len('+123456-01-23T12:34:56.123+12:34')
-+ *   32
-+ * Include additional space to be safe.
-+ */
-+#define  DUK_BI_DATE_ISO8601_BUFSIZE  48
-+
-+/* Buffer size for "short log message" which use a heap-level pre-allocated
-+ * dynamic buffer to reduce memory churn.
-+ */
-+#define  DUK_BI_LOGGER_SHORT_MSG_LIMIT  256
-+
-+/* Maximum length of CommonJS module identifier to resolve.  Length includes
-+ * both current module ID, requested (possibly relative) module ID, and a
-+ * slash in between.
-+ */
-+#define  DUK_BI_COMMONJS_MODULE_ID_LIMIT  256
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_constructor_is_array(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_to_string(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_concat(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_join_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_pop(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_push(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reverse(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_shift(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_slice(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_sort(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_splice(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_unshift(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_indexof_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_iter_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_array_prototype_reduce_shared(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_boolean_prototype_tostring_shared(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_parse(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_utc(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_constructor_now(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_tostring_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_value_of(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_to_json(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_get_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_get_timezone_offset(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_set_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_date_prototype_set_time(duk_context *ctx);
-+/* Helpers exposed for internal use */
-+DUK_INTERNAL_DECL duk_double_t duk_bi_date_get_now(duk_context *ctx);
-+DUK_INTERNAL_DECL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t *out_buf);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_act(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_gc(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_fin(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_enc(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_dec(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_duktape_object_compact(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_error_constructor_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_stack_getter(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_filename_getter(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_error_prototype_nop_setter(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_function_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_to_string(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_apply(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_call(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype_bind(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_eval(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_parse_int(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_parse_float(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_is_nan(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_is_finite(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_decode_uri(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_decode_uri_component(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_encode_uri(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_encode_uri_component(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_escape(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_global_object_require(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL
-+void duk_bi_json_parse_helper(duk_context *ctx,
-+                              duk_idx_t idx_value,
-+                              duk_idx_t idx_reviver,
-+                              duk_small_uint_t flags);
-+DUK_INTERNAL_DECL
-+void duk_bi_json_stringify_helper(duk_context *ctx,
-+                                  duk_idx_t idx_value,
-+                                  duk_idx_t idx_replacer,
-+                                  duk_idx_t idx_space,
-+                                  duk_small_uint_t flags);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_json_object_parse(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_json_object_stringify(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_max(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_min(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_math_object_random(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_number_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_string(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_locale_string(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_value_of(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_fixed(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_exponential(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_number_prototype_to_precision(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_define_property(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_define_properties(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_seal_freeze_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_prevent_extensions(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_is_extensible(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_to_string(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_to_locale_string(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_value_of(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_has_own_property(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_object_prototype_property_is_enumerable(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_pointer_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_pointer_prototype_tostring_shared(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_exec(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_test(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_to_string(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_char_at(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_char_code_at(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_concat(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_indexof_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_locale_compare(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_slice(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_split(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substring(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_caseconv_shared(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_trim(duk_context *ctx);
-+/* Note: present even if DUK_OPT_NO_SECTION_B given because genbuiltins.py
-+ * will point to it.
-+ */
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx);
-+#if 0  /* unimplemented now */
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_proxy_constructor_revocable(duk_context *ctx);
-+#endif
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_resume(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_yield(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_thread_current(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_constructor(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_fmt(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_raw(duk_context *ctx);
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx);
-+
-+DUK_INTERNAL_DECL duk_ret_t duk_bi_type_error_thrower(duk_context *ctx);
-+
-+#endif  /* DUK_BUILTIN_PROTOS_H_INCLUDED */
-+#line 1 "duk_selftest.h"
-+/*
-+ *  Selftest code
-+ */
-+
-+#ifndef DUK_SELFTEST_H_INCLUDED
-+#define DUK_SELFTEST_H_INCLUDED
-+
-+#if defined(DUK_USE_SELF_TESTS)
-+DUK_INTERNAL_DECL void duk_selftest_run_tests(void);
-+#endif
-+
-+#endif  /* DUK_SELFTEST_H_INCLUDED */
-+#line 76 "duk_internal.h"
-+
-+#endif  /* DUK_INTERNAL_H_INCLUDED */
-+#line 1 "duk_strings.c"
-+/*
-+ *  Shared error message strings
-+ *
-+ *  To minimize code footprint, try to share error messages inside Duktape
-+ *  code.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* Mostly API and built-in method related */
-+DUK_INTERNAL const char *duk_str_internal_error = "internal error";
-+DUK_INTERNAL const char *duk_str_invalid_count = "invalid count";
-+DUK_INTERNAL const char *duk_str_invalid_call_args = "invalid call args";
-+DUK_INTERNAL const char *duk_str_not_constructable = "not constructable";
-+DUK_INTERNAL const char *duk_str_not_callable = "not callable";
-+DUK_INTERNAL const char *duk_str_not_extensible = "not extensible";
-+DUK_INTERNAL const char *duk_str_not_writable = "not writable";
-+DUK_INTERNAL const char *duk_str_not_configurable = "not configurable";
-+
-+DUK_INTERNAL const char *duk_str_invalid_context = "invalid context";
-+DUK_INTERNAL const char *duk_str_invalid_index = "invalid index";
-+DUK_INTERNAL const char *duk_str_push_beyond_alloc_stack = "attempt to push beyond currently allocated stack";
-+DUK_INTERNAL const char *duk_str_not_undefined = "not undefined";
-+DUK_INTERNAL const char *duk_str_not_null = "not null";
-+DUK_INTERNAL const char *duk_str_not_boolean = "not boolean";
-+DUK_INTERNAL const char *duk_str_not_number = "not number";
-+DUK_INTERNAL const char *duk_str_not_string = "not string";
-+DUK_INTERNAL const char *duk_str_not_pointer = "not pointer";
-+DUK_INTERNAL const char *duk_str_not_buffer = "not buffer";
-+DUK_INTERNAL const char *duk_str_unexpected_type = "unexpected type";
-+DUK_INTERNAL const char *duk_str_not_thread = "not thread";
-+#if 0  /*unused*/
-+DUK_INTERNAL const char *duk_str_not_compiledfunction = "not compiledfunction";
-+#endif
-+DUK_INTERNAL const char *duk_str_not_nativefunction = "not nativefunction";
-+DUK_INTERNAL const char *duk_str_not_c_function = "not c function";
-+DUK_INTERNAL const char *duk_str_defaultvalue_coerce_failed = "[[DefaultValue]] coerce failed";
-+DUK_INTERNAL const char *duk_str_number_outside_range = "number outside range";
-+DUK_INTERNAL const char *duk_str_not_object_coercible = "not object coercible";
-+DUK_INTERNAL const char *duk_str_string_too_long = "string too long";
-+DUK_INTERNAL const char *duk_str_buffer_too_long = "buffer too long";
-+DUK_INTERNAL const char *duk_str_sprintf_too_long = "sprintf message too long";
-+DUK_INTERNAL const char *duk_str_object_alloc_failed = "object alloc failed";
-+DUK_INTERNAL const char *duk_str_thread_alloc_failed = "thread alloc failed";
-+DUK_INTERNAL const char *duk_str_func_alloc_failed = "func alloc failed";
-+DUK_INTERNAL const char *duk_str_buffer_alloc_failed = "buffer alloc failed";
-+DUK_INTERNAL const char *duk_str_pop_too_many = "attempt to pop too many entries";
-+DUK_INTERNAL const char *duk_str_buffer_not_dynamic = "buffer is not dynamic";
-+DUK_INTERNAL const char *duk_str_failed_to_extend_valstack = "failed to extend valstack";
-+DUK_INTERNAL const char *duk_str_base64_encode_failed = "base64 encode failed";
-+DUK_INTERNAL const char *duk_str_base64_decode_failed = "base64 decode failed";
-+DUK_INTERNAL const char *duk_str_hex_decode_failed = "hex decode failed";
-+DUK_INTERNAL const char *duk_str_no_sourcecode = "no sourcecode";
-+DUK_INTERNAL const char *duk_str_concat_result_too_long = "concat result too long";
-+DUK_INTERNAL const char *duk_str_unimplemented = "unimplemented";
-+DUK_INTERNAL const char *duk_str_array_length_over_2g = "array length over 2G";
-+
-+/* JSON */
-+DUK_INTERNAL const char *duk_str_fmt_ptr = "%p";
-+DUK_INTERNAL const char *duk_str_fmt_invalid_json = "invalid json (at offset %ld)";
-+DUK_INTERNAL const char *duk_str_jsondec_reclimit = "json decode recursion limit";
-+DUK_INTERNAL const char *duk_str_jsonenc_reclimit = "json encode recursion limit";
-+DUK_INTERNAL const char *duk_str_cyclic_input = "cyclic input";
-+
-+/* Object property access */
-+DUK_INTERNAL const char *duk_str_proxy_revoked = "proxy revoked";
-+DUK_INTERNAL const char *duk_str_object_resize_failed = "object resize failed";
-+DUK_INTERNAL const char *duk_str_invalid_base = "invalid base value";
-+DUK_INTERNAL const char *duk_str_strict_caller_read = "attempt to read strict 'caller'";
-+DUK_INTERNAL const char *duk_str_proxy_rejected = "proxy rejected";
-+DUK_INTERNAL const char *duk_str_invalid_array_length = "invalid array length";
-+DUK_INTERNAL const char *duk_str_array_length_write_failed = "array length write failed";
-+DUK_INTERNAL const char *duk_str_array_length_not_writable = "array length non-writable";
-+DUK_INTERNAL const char *duk_str_setter_undefined = "setter undefined";
-+DUK_INTERNAL const char *duk_str_redefine_virt_prop = "attempt to redefine virtual property";
-+DUK_INTERNAL const char *duk_str_invalid_descriptor = "invalid descriptor";
-+DUK_INTERNAL const char *duk_str_property_is_virtual = "property is virtual";
-+
-+/* Compiler */
-+DUK_INTERNAL const char *duk_str_parse_error = "parse error";
-+DUK_INTERNAL const char *duk_str_duplicate_label = "duplicate label";
-+DUK_INTERNAL const char *duk_str_invalid_label = "invalid label";
-+DUK_INTERNAL const char *duk_str_invalid_array_literal = "invalid array literal";
-+DUK_INTERNAL const char *duk_str_invalid_object_literal = "invalid object literal";
-+DUK_INTERNAL const char *duk_str_invalid_var_declaration = "invalid variable declaration";
-+DUK_INTERNAL const char *duk_str_cannot_delete_identifier = "cannot delete identifier";
-+DUK_INTERNAL const char *duk_str_invalid_expression = "invalid expression";
-+DUK_INTERNAL const char *duk_str_invalid_lvalue = "invalid lvalue";
-+DUK_INTERNAL const char *duk_str_expected_identifier = "expected identifier";
-+DUK_INTERNAL const char *duk_str_empty_expr_not_allowed = "empty expression not allowed";
-+DUK_INTERNAL const char *duk_str_invalid_for = "invalid for statement";
-+DUK_INTERNAL const char *duk_str_invalid_switch = "invalid switch statement";
-+DUK_INTERNAL const char *duk_str_invalid_break_cont_label = "invalid break/continue label";
-+DUK_INTERNAL const char *duk_str_invalid_return = "invalid return";
-+DUK_INTERNAL const char *duk_str_invalid_try = "invalid try";
-+DUK_INTERNAL const char *duk_str_invalid_throw = "invalid throw";
-+DUK_INTERNAL const char *duk_str_with_in_strict_mode = "with in strict mode";
-+DUK_INTERNAL const char *duk_str_func_stmt_not_allowed = "function statement not allowed";
-+DUK_INTERNAL const char *duk_str_unterminated_stmt = "unterminated statement";
-+DUK_INTERNAL const char *duk_str_invalid_arg_name = "invalid argument name";
-+DUK_INTERNAL const char *duk_str_invalid_func_name = "invalid function name";
-+DUK_INTERNAL const char *duk_str_invalid_getset_name = "invalid getter/setter name";
-+DUK_INTERNAL const char *duk_str_func_name_required = "function name required";
-+
-+/* Executor */
-+DUK_INTERNAL const char *duk_str_internal_error_exec_longjmp = "internal error in bytecode executor longjmp handler";
-+
-+/* Regexp */
-+DUK_INTERNAL const char *duk_str_invalid_quantifier_no_atom = "quantifier without preceding atom";
-+DUK_INTERNAL const char *duk_str_invalid_quantifier_values = "quantifier values invalid (qmin > qmax)";
-+DUK_INTERNAL const char *duk_str_quantifier_too_many_copies = "quantifier expansion requires too many atom copies";
-+DUK_INTERNAL const char *duk_str_unexpected_closing_paren = "unexpected closing parenthesis";
-+DUK_INTERNAL const char *duk_str_unexpected_end_of_pattern = "unexpected end of pattern";
-+DUK_INTERNAL const char *duk_str_unexpected_regexp_token = "unexpected token in regexp";
-+DUK_INTERNAL const char *duk_str_invalid_regexp_flags = "invalid regexp flags";
-+DUK_INTERNAL const char *duk_str_invalid_backrefs = "invalid backreference(s)";
-+DUK_INTERNAL const char *duk_str_regexp_backtrack_failed = "regexp backtrack failed";
-+DUK_INTERNAL const char *duk_str_regexp_advance_failed = "regexp advance failed";
-+DUK_INTERNAL const char *duk_str_regexp_internal_error = "regexp internal error";
-+
-+/* Limits */
-+DUK_INTERNAL const char *duk_str_valstack_limit = "valstack limit";
-+DUK_INTERNAL const char *duk_str_callstack_limit = "callstack limit";
-+DUK_INTERNAL const char *duk_str_catchstack_limit = "catchstack limit";
-+DUK_INTERNAL const char *duk_str_object_property_limit = "object property limit";
-+DUK_INTERNAL const char *duk_str_prototype_chain_limit = "prototype chain limit";
-+DUK_INTERNAL const char *duk_str_bound_chain_limit = "function call bound chain limit";
-+DUK_INTERNAL const char *duk_str_c_callstack_limit = "C call stack depth limit";
-+DUK_INTERNAL const char *duk_str_compiler_recursion_limit = "compiler recursion limit";
-+DUK_INTERNAL const char *duk_str_bytecode_limit = "bytecode limit";
-+DUK_INTERNAL const char *duk_str_reg_limit = "register limit";
-+DUK_INTERNAL const char *duk_str_temp_limit = "temp limit";
-+DUK_INTERNAL const char *duk_str_const_limit = "const limit";
-+DUK_INTERNAL const char *duk_str_func_limit = "function limit";
-+DUK_INTERNAL const char *duk_str_regexp_compiler_recursion_limit = "regexp compiler recursion limit";
-+DUK_INTERNAL const char *duk_str_regexp_executor_recursion_limit = "regexp executor recursion limit";
-+DUK_INTERNAL const char *duk_str_regexp_executor_step_limit = "regexp step limit";
-+
-+/* Misc */
-+DUK_INTERNAL const char *duk_str_anon = "anon";
-+DUK_INTERNAL const char *duk_str_realloc_failed = "realloc failed";
-+#line 1 "duk_debug_macros.c"
-+/*
-+ *  Debugging macro calls.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_DEBUG
-+
-+/*
-+ *  Debugging enabled
-+ */
-+
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <stdarg.h>
-+
-+#define DUK__DEBUG_BUFSIZE  DUK_USE_DEBUG_BUFSIZE
-+DUK_LOCAL char duk__debug_buf[DUK__DEBUG_BUFSIZE];
-+
-+DUK_LOCAL const char *duk__get_level_string(duk_small_int_t level) {
-+	switch ((int) level) {
-+	case DUK_LEVEL_DEBUG:
-+		return "D";
-+	case DUK_LEVEL_DDEBUG:
-+		return "DD";
-+	case DUK_LEVEL_DDDEBUG:
-+		return "DDD";
-+	}
-+	return "???";
-+}
-+
-+#ifdef DUK_USE_DPRINT_COLORS
-+
-+/* http://en.wikipedia.org/wiki/ANSI_escape_code */
-+#define DUK__TERM_REVERSE  "\x1b[7m"
-+#define DUK__TERM_BRIGHT   "\x1b[1m"
-+#define DUK__TERM_RESET    "\x1b[0m"
-+#define DUK__TERM_BLUE     "\x1b[34m"
-+#define DUK__TERM_RED      "\x1b[31m"
-+
-+DUK_LOCAL const char *duk__get_term_1(duk_small_int_t level) {
-+	DUK_UNREF(level);
-+	return (const char *) DUK__TERM_RED;
-+}
-+
-+DUK_LOCAL const char *duk__get_term_2(duk_small_int_t level) {
-+	switch ((int) level) {
-+	case DUK_LEVEL_DEBUG:
-+		return (const char *) (DUK__TERM_RESET DUK__TERM_BRIGHT);
-+	case DUK_LEVEL_DDEBUG:
-+		return (const char *) (DUK__TERM_RESET);
-+	case DUK_LEVEL_DDDEBUG:
-+		return (const char *) (DUK__TERM_RESET DUK__TERM_BLUE);
-+	}
-+	return (const char *) DUK__TERM_RESET;
-+}
-+
-+DUK_LOCAL const char *duk__get_term_3(duk_small_int_t level) {
-+	DUK_UNREF(level);
-+	return (const char *) DUK__TERM_RESET;
-+}
-+
-+#else
-+
-+DUK_LOCAL const char *duk__get_term_1(duk_small_int_t level) {
-+	DUK_UNREF(level);
-+	return (const char *) "";
-+}
-+
-+DUK_LOCAL const char *duk__get_term_2(duk_small_int_t level) {
-+	DUK_UNREF(level);
-+	return (const char *) "";
-+}
-+
-+DUK_LOCAL const char *duk__get_term_3(duk_small_int_t level) {
-+	DUK_UNREF(level);
-+	return (const char *) "";
-+}
-+
-+#endif  /* DUK_USE_DPRINT_COLORS */
-+
-+#ifdef DUK_USE_VARIADIC_MACROS
-+
-+DUK_INTERNAL void duk_debug_log(duk_small_int_t level, const char *file, duk_int_t line, const char *func, const char *fmt, ...) {
-+	va_list ap;
-+
-+	va_start(ap, fmt);
-+
-+	DUK_MEMZERO((void *) duk__debug_buf, (size_t) DUK__DEBUG_BUFSIZE);
-+	duk_debug_vsnprintf(duk__debug_buf, DUK__DEBUG_BUFSIZE - 1, fmt, ap);
-+
-+#ifdef DUK_USE_DPRINT_RDTSC
-+	DUK_FPRINTF(DUK_STDERR, "%s[%s] <%llu> %s:%ld (%s):%s %s%s\n",
-+	            (const char *) duk__get_term_1(level),
-+	            (const char *) duk__get_level_string(level),
-+	            (unsigned long long) duk_rdtsc(),  /* match the inline asm in duk_features.h */
-+	            (const char *) file,
-+	            (long) line,
-+	            (const char *) func,
-+	            (const char *) duk__get_term_2(level),
-+	            (const char *) duk__debug_buf,
-+	            (const char *) duk__get_term_3(level));
-+#else
-+	DUK_FPRINTF(DUK_STDERR, "%s[%s] %s:%ld (%s):%s %s%s\n",
-+	            (const char *) duk__get_term_1(level),
-+	            (const char *) duk__get_level_string(level),
-+	            (const char *) file,
-+	            (long) line,
-+	            (const char *) func,
-+	            (const char *) duk__get_term_2(level),
-+	            (const char *) duk__debug_buf,
-+	            (const char *) duk__get_term_3(level));
-+#endif
-+	DUK_FFLUSH(DUK_STDERR);
-+
-+	va_end(ap);
-+}
-+
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+
-+DUK_INTERNAL char duk_debug_file_stash[DUK_DEBUG_STASH_SIZE];
-+DUK_INTERNAL char duk_debug_line_stash[DUK_DEBUG_STASH_SIZE];
-+DUK_INTERNAL char duk_debug_func_stash[DUK_DEBUG_STASH_SIZE];
-+DUK_INTERNAL duk_small_int_t duk_debug_level_stash;
-+
-+DUK_INTERNAL void duk_debug_log(const char *fmt, ...) {
-+	va_list ap;
-+	duk_small_int_t level = duk_debug_level_stash;
-+
-+	va_start(ap, fmt);
-+
-+	DUK_MEMZERO((void *) duk__debug_buf, (size_t) DUK__DEBUG_BUFSIZE);
-+	duk_debug_vsnprintf(duk__debug_buf, DUK__DEBUG_BUFSIZE - 1, fmt, ap);
-+
-+#ifdef DUK_USE_DPRINT_RDTSC
-+	DUK_FPRINTF(DUK_STDERR, "%s[%s] <%llu> %s:%s (%s):%s %s%s\n",
-+	            (const char *) duk__get_term_1(level),
-+	            (const char *) duk__get_level_string(duk_debug_level_stash),
-+	            (unsigned long long) duk_rdtsc(),  /* match duk_features.h */
-+	            (const char *) duk_debug_file_stash,
-+	            (const char *) duk_debug_line_stash,
-+	            (const char *) duk_debug_func_stash,
-+	            (const char *) duk__get_term_2(level),
-+	            (const char *) duk__debug_buf,
-+	            (const char *) duk__get_term_3(level));
-+#else
-+	DUK_FPRINTF(DUK_STDERR, "%s[%s] %s:%s (%s):%s %s%s\n",
-+	            (const char *) duk__get_term_1(level),
-+	            (const char *) duk__get_level_string(duk_debug_level_stash),
-+	            (const char *) duk_debug_file_stash,
-+	            (const char *) duk_debug_line_stash,
-+	            (const char *) duk_debug_func_stash,
-+	            (const char *) duk__get_term_2(level),
-+	            (const char *) duk__debug_buf,
-+	            (const char *) duk__get_term_3(level));
-+#endif
-+	DUK_FFLUSH(DUK_STDERR);
-+
-+	va_end(ap);
-+}
-+
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+#else  /* DUK_USE_DEBUG */
-+
-+/*
-+ *  Debugging disabled
-+ */
-+
-+#endif  /* DUK_USE_DEBUG */
-+#line 1 "duk_builtins.c"
-+/*
-+ *  Automatically generated by genbuiltins.py, do not edit!
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#if defined(DUK_USE_DOUBLE_LE)
-+DUK_INTERNAL const duk_uint8_t duk_strings_data[1943] = {
-+55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,26,20,164,137,
-+186,50,11,164,109,77,215,5,61,35,106,3,25,110,8,22,158,130,38,163,8,217,
-+200,158,76,156,210,117,128,153,203,210,70,46,137,187,18,27,164,187,201,209,
-+130,100,55,91,70,4,145,63,66,231,44,128,105,187,41,197,13,49,122,8,196,24,
-+71,75,70,138,104,115,77,215,5,36,20,201,214,209,107,79,104,209,144,168,105,
-+6,207,251,209,104,209,125,212,227,66,127,235,191,239,232,180,90,52,95,69,
-+247,83,141,9,255,174,255,191,162,211,80,210,253,23,221,78,52,39,254,183,
-+254,254,139,72,105,126,139,238,167,26,19,255,91,255,127,69,166,129,191,69,
-+247,83,141,9,255,175,255,191,162,213,26,50,23,232,190,234,113,161,63,245,
-+115,119,86,227,118,83,138,26,98,9,110,48,86,22,148,160,152,22,82,70,46,137,
-+44,8,180,163,32,104,98,206,32,17,7,16,88,101,100,206,42,70,36,108,205,18,
-+74,140,33,196,230,60,2,152,146,33,38,230,8,36,79,182,251,65,156,151,24,200,
-+33,145,162,25,80,209,24,67,0,166,68,52,174,61,73,25,33,205,25,27,84,177,
-+195,234,220,1,144,105,99,135,217,16,17,17,208,72,199,179,60,93,100,146,49,
-+232,162,64,76,135,19,152,244,44,136,223,98,67,4,18,33,247,217,158,36,0,209,
-+190,156,13,26,201,21,111,165,67,64,180,100,145,62,250,32,45,100,33,55,214,
-+1,229,223,65,19,72,187,236,206,137,35,125,120,190,201,104,105,15,190,201,
-+212,136,136,125,246,160,137,27,83,239,171,37,200,218,159,125,168,34,192,61,
-+27,233,93,22,1,114,78,250,28,76,130,112,200,93,245,164,188,207,190,204,17,
-+49,38,109,246,160,93,8,119,185,13,153,34,96,208,165,36,85,190,206,32,17,6,
-+9,129,75,67,73,214,209,129,36,80,84,44,157,104,24,65,60,69,148,192,37,59,
-+179,60,93,110,207,15,39,73,24,186,39,232,232,169,129,228,18,6,120,146,20,
-+68,72,157,105,241,116,221,173,58,68,159,95,23,77,211,195,201,215,20,238,
-+179,122,162,98,73,35,104,194,68,19,35,134,69,146,100,235,226,231,146,51,
-+192,206,9,23,175,139,175,131,8,11,89,8,206,161,181,2,208,63,160,232,193,50,
-+23,246,254,187,235,190,187,247,69,241,95,18,31,160,15,214,11,235,126,192,
-+95,87,246,1,251,4,253,111,80,210,161,168,158,19,245,125,67,74,134,162,120,
-+71,80,210,161,168,158,12,224,164,130,153,165,56,161,166,51,104,192,146,39,
-+11,156,178,1,169,163,70,66,161,164,26,101,56,161,166,65,112,57,129,164,148,
-+35,49,201,13,44,93,70,140,209,3,70,230,13,238,176,216,134,141,128,184,214,
-+227,20,171,115,162,50,93,227,19,164,65,17,11,40,38,6,253,145,1,48,52,128,
-+146,26,64,9,210,24,3,34,250,80,140,254,200,254,148,35,63,177,215,217,11,
-+207,65,188,183,27,236,126,192,133,242,220,111,178,32,252,182,253,145,60,
-+182,253,143,216,7,164,59,9,41,0,196,35,64,194,21,13,125,38,84,52,100,185,
-+62,163,239,254,235,234,82,176,74,125,67,70,75,165,148,92,208,180,52,138,65,
-+154,232,147,162,4,136,105,58,145,17,9,50,74,100,37,200,37,205,222,51,39,47,
-+78,40,105,143,34,79,184,32,34,115,18,125,193,1,19,77,222,76,156,213,205,
-+222,68,157,47,78,40,105,151,55,122,147,20,189,56,161,166,116,137,63,82,98,
-+47,168,181,247,4,4,87,34,79,165,162,215,220,16,17,92,137,63,82,98,103,156,
-+217,157,18,36,250,199,54,103,84,137,63,82,98,31,129,50,30,68,159,70,9,145,
-+114,36,253,73,136,254,117,35,36,72,147,233,221,72,201,178,36,253,73,137,
-+158,67,105,50,73,82,36,250,196,54,147,36,155,34,79,212,152,165,226,9,205,
-+28,149,34,79,178,32,156,209,202,82,36,253,73,137,158,66,214,137,16,78,104,
-+228,249,18,125,98,22,180,72,130,115,71,35,200,147,236,208,194,68,196,159,
-+102,134,19,46,105,58,226,150,68,156,140,73,250,147,19,60,133,173,18,32,156,
-+209,201,230,36,250,196,45,104,145,4,230,142,77,49,39,234,76,82,241,4,230,
-+142,74,49,39,217,16,78,104,228,211,18,126,164,196,207,33,180,153,36,163,18,
-+125,98,27,73,146,75,49,39,234,76,71,243,169,25,32,196,159,78,234,70,73,49,
-+39,234,76,67,240,48,99,18,125,24,48,163,18,126,164,196,63,2,100,57,137,62,
-+140,19,34,204,73,250,147,19,60,230,204,232,49,39,214,57,179,59,140,73,250,
-+147,17,125,69,175,184,32,34,179,18,125,45,22,190,224,128,137,204,73,246,
-+104,97,37,55,117,110,16,22,78,205,12,39,101,56,161,166,148,221,213,184,64,
-+89,58,48,76,157,148,226,134,153,147,119,102,134,19,178,156,80,211,50,110,
-+232,193,50,118,83,138,26,97,181,214,31,169,49,21,224,140,136,185,187,175,
-+137,4,137,33,205,108,221,210,93,238,105,27,52,1,103,155,186,84,92,131,143,
-+158,233,34,104,169,52,134,149,13,68,241,31,52,134,4,209,82,105,13,42,26,
-+137,224,125,104,58,212,249,136,110,170,5,208,137,243,1,125,84,11,161,13,42,
-+6,83,137,39,20,50,51,119,86,225,1,100,237,30,242,71,162,4,136,185,187,180,
-+123,201,30,136,18,36,102,238,173,194,2,201,213,186,196,143,68,9,17,115,119,
-+86,235,18,61,16,36,68,202,129,148,226,134,152,178,122,209,51,72,128,136,
-+142,120,145,235,0,136,86,2,98,59,86,225,1,100,232,156,199,130,36,80,142,8,
-+244,78,25,58,9,152,71,4,122,9,176,177,115,58,35,130,61,19,134,69,196,131,
-+160,137,216,160,199,153,162,65,208,68,49,80,185,146,35,96,30,114,186,61,32,
-+4,114,73,204,33,73,82,71,11,88,37,62,161,163,37,250,226,157,13,25,47,215,
-+20,244,108,142,130,204,210,122,208,34,18,78,140,203,37,160,68,44,142,130,
-+204,241,37,73,25,16,143,164,142,55,185,228,75,144,211,9,205,16,38,116,75,
-+160,140,65,132,130,38,163,8,217,200,194,2,214,72,144,40,104,200,32,45,101,
-+3,222,188,81,241,115,201,25,227,168,151,72,218,48,145,0,86,70,162,93,124,
-+93,55,79,15,39,92,87,28,18,235,172,222,190,46,121,35,60,30,160,93,9,215,21,
-+211,119,86,225,1,100,236,167,20,52,200,155,187,41,197,13,50,196,230,202,
-+113,160,166,232,142,68,152,204,73,168,141,163,9,16,5,100,96,156,210,160,
-+212,136,2,178,34,209,68,192,21,144,181,2,232,66,40,152,147,17,46,146,243,
-+35,100,128,172,136,68,186,88,187,36,106,17,46,200,128,89,7,23,196,149,35,
-+103,210,94,100,108,144,230,200,197,137,9,146,18,68,2,224,50,21,13,39,95,23,
-+60,145,154,9,39,12,133,67,73,215,197,207,36,103,131,10,36,4,201,51,18,125,
-+117,155,215,197,207,36,103,142,180,12,36,176,98,79,174,179,122,248,185,228,
-+140,241,209,146,66,138,31,55,69,198,36,250,248,186,110,158,30,78,184,169,
-+124,93,55,79,15,33,150,70,154,103,40,22,72,204,175,138,27,52,81,164,144,
-+128,242,24,146,16,30,73,17,162,112,201,234,69,2,243,152,247,52,141,154,72,
-+209,56,100,245,34,137,12,130,112,201,234,69,2,243,152,247,52,141,154,70,65,
-+56,100,245,34,132,34,93,42,26,137,144,168,151,90,14,181,79,4,100,78,149,
-+110,4,208,240,70,68,234,27,50,18,160,90,61,72,160,158,140,93,20,246,120,
-+121,58,72,197,209,95,101,134,204,23,233,35,23,69,221,137,10,72,145,162,39,
-+73,24,186,42,236,64,211,19,164,140,93,20,244,149,2,250,72,197,209,40,98,64,
-+40,130,4,136,81,2,98,58,4,230,205,13,161,16,50,6,134,49,34,113,144,160,162,
-+230,97,145,100,153,4,55,16,139,145,14,84,52,11,94,6,87,69,5,163,69,52,57,
-+162,65,68,134,169,13,148,192,209,17,197,27,73,99,68,147,164,90,105,89,19,
-+17,201,51,162,69,153,226,235,14,113,193,167,135,145,197,29,65,18,85,200,25,
-+108,116,44,132,178,38,114,137,96,148,138,39,54,83,33,27,70,24,151,123,163,
-+51,146,243,35,71,35,33,143,116,102,89,81,228,137,27,69,172,147,141,8,82,
-+129,114,34,144,199,172,140,35,103,36,161,179,36,74,1,16,107,36,206,240,9,
-+64,49,14,248,162,160,153,18,248,186,100,20,200,51,62,129,90,4,105,76,19,64,
-+139,132,17,99,
-+};
-+
-+/* to convert a heap stridx to a token number, subtract
-+ * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED.
-+ */
-+
-+/* native functions: 128 */
-+DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = {
-+	duk_bi_array_constructor,
-+	duk_bi_array_constructor_is_array,
-+	duk_bi_array_prototype_concat,
-+	duk_bi_array_prototype_indexof_shared,
-+	duk_bi_array_prototype_iter_shared,
-+	duk_bi_array_prototype_join_shared,
-+	duk_bi_array_prototype_pop,
-+	duk_bi_array_prototype_push,
-+	duk_bi_array_prototype_reduce_shared,
-+	duk_bi_array_prototype_reverse,
-+	duk_bi_array_prototype_shift,
-+	duk_bi_array_prototype_slice,
-+	duk_bi_array_prototype_sort,
-+	duk_bi_array_prototype_splice,
-+	duk_bi_array_prototype_to_string,
-+	duk_bi_array_prototype_unshift,
-+	duk_bi_boolean_constructor,
-+	duk_bi_boolean_prototype_tostring_shared,
-+	duk_bi_buffer_constructor,
-+	duk_bi_buffer_prototype_tostring_shared,
-+	duk_bi_date_constructor,
-+	duk_bi_date_constructor_now,
-+	duk_bi_date_constructor_parse,
-+	duk_bi_date_constructor_utc,
-+	duk_bi_date_prototype_get_shared,
-+	duk_bi_date_prototype_get_timezone_offset,
-+	duk_bi_date_prototype_set_shared,
-+	duk_bi_date_prototype_set_time,
-+	duk_bi_date_prototype_to_json,
-+	duk_bi_date_prototype_tostring_shared,
-+	duk_bi_date_prototype_value_of,
-+	duk_bi_duktape_object_act,
-+	duk_bi_duktape_object_compact,
-+	duk_bi_duktape_object_dec,
-+	duk_bi_duktape_object_enc,
-+	duk_bi_duktape_object_fin,
-+	duk_bi_duktape_object_gc,
-+	duk_bi_duktape_object_info,
-+	duk_bi_error_constructor_shared,
-+	duk_bi_error_prototype_filename_getter,
-+	duk_bi_error_prototype_linenumber_getter,
-+	duk_bi_error_prototype_nop_setter,
-+	duk_bi_error_prototype_stack_getter,
-+	duk_bi_error_prototype_to_string,
-+	duk_bi_function_constructor,
-+	duk_bi_function_prototype,
-+	duk_bi_function_prototype_apply,
-+	duk_bi_function_prototype_bind,
-+	duk_bi_function_prototype_call,
-+	duk_bi_function_prototype_to_string,
-+	duk_bi_global_object_decode_uri,
-+	duk_bi_global_object_decode_uri_component,
-+	duk_bi_global_object_encode_uri,
-+	duk_bi_global_object_encode_uri_component,
-+	duk_bi_global_object_escape,
-+	duk_bi_global_object_eval,
-+	duk_bi_global_object_is_finite,
-+	duk_bi_global_object_is_nan,
-+	duk_bi_global_object_parse_float,
-+	duk_bi_global_object_parse_int,
-+	duk_bi_global_object_print_helper,
-+	duk_bi_global_object_require,
-+	duk_bi_global_object_unescape,
-+	duk_bi_json_object_parse,
-+	duk_bi_json_object_stringify,
-+	duk_bi_logger_constructor,
-+	duk_bi_logger_prototype_fmt,
-+	duk_bi_logger_prototype_log_shared,
-+	duk_bi_logger_prototype_raw,
-+	duk_bi_math_object_max,
-+	duk_bi_math_object_min,
-+	duk_bi_math_object_onearg_shared,
-+	duk_bi_math_object_random,
-+	duk_bi_math_object_twoarg_shared,
-+	duk_bi_number_constructor,
-+	duk_bi_number_prototype_to_exponential,
-+	duk_bi_number_prototype_to_fixed,
-+	duk_bi_number_prototype_to_locale_string,
-+	duk_bi_number_prototype_to_precision,
-+	duk_bi_number_prototype_to_string,
-+	duk_bi_number_prototype_value_of,
-+	duk_bi_object_constructor,
-+	duk_bi_object_constructor_create,
-+	duk_bi_object_constructor_define_properties,
-+	duk_bi_object_constructor_define_property,
-+	duk_bi_object_constructor_get_own_property_descriptor,
-+	duk_bi_object_constructor_is_extensible,
-+	duk_bi_object_constructor_is_sealed_frozen_shared,
-+	duk_bi_object_constructor_keys_shared,
-+	duk_bi_object_constructor_prevent_extensions,
-+	duk_bi_object_constructor_seal_freeze_shared,
-+	duk_bi_object_getprototype_shared,
-+	duk_bi_object_prototype_has_own_property,
-+	duk_bi_object_prototype_is_prototype_of,
-+	duk_bi_object_prototype_property_is_enumerable,
-+	duk_bi_object_prototype_to_locale_string,
-+	duk_bi_object_prototype_to_string,
-+	duk_bi_object_prototype_value_of,
-+	duk_bi_object_setprototype_shared,
-+	duk_bi_pointer_constructor,
-+	duk_bi_pointer_prototype_tostring_shared,
-+	duk_bi_proxy_constructor,
-+	duk_bi_regexp_constructor,
-+	duk_bi_regexp_prototype_exec,
-+	duk_bi_regexp_prototype_test,
-+	duk_bi_regexp_prototype_to_string,
-+	duk_bi_string_constructor,
-+	duk_bi_string_constructor_from_char_code,
-+	duk_bi_string_prototype_caseconv_shared,
-+	duk_bi_string_prototype_char_at,
-+	duk_bi_string_prototype_char_code_at,
-+	duk_bi_string_prototype_concat,
-+	duk_bi_string_prototype_indexof_shared,
-+	duk_bi_string_prototype_locale_compare,
-+	duk_bi_string_prototype_match,
-+	duk_bi_string_prototype_replace,
-+	duk_bi_string_prototype_search,
-+	duk_bi_string_prototype_slice,
-+	duk_bi_string_prototype_split,
-+	duk_bi_string_prototype_substr,
-+	duk_bi_string_prototype_substring,
-+	duk_bi_string_prototype_to_string,
-+	duk_bi_string_prototype_trim,
-+	duk_bi_thread_constructor,
-+	duk_bi_thread_current,
-+	duk_bi_thread_resume,
-+	duk_bi_thread_yield,
-+	duk_bi_type_error_thrower,
-+};
-+
-+DUK_INTERNAL const duk_uint8_t duk_builtins_data[1341] = {
-+105,195,74,136,77,40,105,44,9,124,104,45,3,3,72,0,71,225,65,165,168,33,243,
-+6,145,0,122,24,210,148,14,249,35,120,160,55,226,13,76,192,196,177,164,152,
-+22,192,4,202,52,147,72,152,0,169,70,146,105,11,0,23,40,210,77,32,96,3,37,
-+26,73,163,236,0,108,163,73,52,121,128,14,148,105,38,142,176,1,242,144,56,
-+208,254,84,6,166,82,242,80,210,246,1,250,67,72,144,15,232,13,44,96,47,162,
-+52,160,128,62,80,160,255,253,102,76,0,0,0,0,0,0,15,135,243,84,0,0,0,0,0,0,
-+15,7,243,124,64,153,132,18,49,2,38,48,64,200,7,153,64,227,48,26,103,3,13,0,
-+89,165,34,53,36,38,180,128,216,143,155,81,227,114,58,111,2,142,0,73,194,94,
-+56,202,167,33,209,195,114,70,206,209,26,58,36,100,228,145,131,130,69,204,
-+137,22,51,36,84,208,145,67,82,68,205,137,18,62,36,68,240,122,32,120,62,0,2,
-+87,61,39,255,254,9,46,24,0,10,31,224,29,13,91,40,0,9,101,137,32,0,48,197,
-+84,66,214,9,10,82,68,37,81,144,133,52,65,214,137,6,90,40,0,12,21,100,144,
-+69,114,64,213,202,0,3,2,86,36,5,96,160,0,63,254,16,37,135,91,98,25,242,192,
-+7,194,248,30,236,32,123,46,17,234,186,71,162,241,5,23,240,0,15,241,1,70,74,
-+3,8,249,49,3,204,185,15,35,3,231,137,121,240,163,254,0,46,224,18,7,248,192,
-+42,249,14,3,224,20,32,0,46,208,35,231,96,41,29,96,192,117,3,159,58,66,64,
-+232,10,3,156,45,14,96,194,57,67,87,156,129,231,206,48,51,240,0,23,16,25,
-+255,255,251,132,16,209,192,8,106,0,2,223,4,53,0,2,111,2,26,128,1,183,65,13,
-+64,1,27,129,7,224,0,45,176,131,255,255,241,73,252,0,91,77,103,193,254,64,
-+36,200,64,101,31,47,32,123,188,129,178,218,70,195,113,29,173,231,206,55,3,
-+71,19,129,168,0,11,93,196,141,103,34,53,92,208,212,116,35,157,213,13,55,
-+100,52,158,16,209,108,3,65,176,12,246,192,128,0,179,155,2,0,2,205,122,3,49,
-+221,2,151,248,0,7,249,64,147,35,4,249,17,8,0,11,220,68,2,155,248,172,184,
-+31,255,255,255,255,255,253,239,236,168,0,32,0,0,0,0,0,0,12,152,0,0,0,0,0,0,
-+31,15,236,120,0,0,0,0,0,0,30,15,236,136,0,0,0,0,0,0,30,31,224,7,249,128,
-+147,32,0,0,0,0,0,0,0,0,12,249,79,35,225,52,143,117,0,49,147,8,197,75,35,17,
-+56,130,159,248,1,176,197,136,194,23,254,96,138,128,63,206,4,153,32,0,0,0,0,
-+0,3,225,254,215,200,232,24,3,161,0,1,95,142,132,0,9,240,58,16,0,53,240,232,
-+64,1,23,163,161,0,5,77,142,132,0,25,52,58,16,0,116,200,225,30,227,192,94,
-+15,1,118,48,16,0,133,208,192,64,2,87,35,1,0,10,92,12,4,0,45,110,48,16,0,
-+197,176,192,64,3,86,163,1,0,14,90,12,4,0,61,102,48,16,1,5,144,192,64,4,86,
-+35,1,0,18,88,12,4,0,77,94,48,16,1,69,112,192,64,5,85,163,1,0,22,86,12,4,0,
-+93,86,50,5,80,217,21,35,69,0,24,84,13,20,0,101,78,52,190,0,52,166,26,95,0,
-+27,82,141,63,128,14,41,6,159,192,7,84,99,83,224,3,202,33,169,240,1,245,8,
-+209,64,8,20,3,69,0,33,79,141,47,128,17,39,134,151,192,8,211,163,79,224,4,
-+137,193,167,240,2,84,192,192,64,9,146,227,69,0,39,21,31,192,0,63,208,24,
-+147,4,12,0,32,41,56,72,240,60,100,148,100,140,100,132,128,0,0,0,0,0,0,0,0,
-+210,172,228,74,52,17,242,210,1,83,252,0,3,253,33,81,132,11,69,144,24,166,
-+229,69,37,23,39,41,40,57,65,72,47,146,176,10,175,224,0,159,234,4,140,41,18,
-+44,128,192,10,191,224,0,159,235,4,140,41,10,44,128,192,10,207,224,0,159,
-+236,4,140,41,2,44,128,192,10,223,224,0,159,237,4,140,40,250,44,128,192,10,
-+239,224,0,159,238,4,140,40,242,44,128,192,10,255,224,0,159,239,4,140,40,
-+234,44,128,192,7,255,228,34,160,52,171,138,69,133,95,130,160,34,96,11,42,
-+218,221,216,181,129,32,34,32,119,156,253,127,33,23,115,31,161,224,127,65,
-+21,178,163,138,251,159,161,160,7,114,147,10,189,229,237,159,161,96,12,22,
-+162,42,125,144,132,160,33,32,102,157,191,179,79,80,115,31,160,224,102,157,
-+191,179,79,80,123,31,164,130,71,34,5,28,160,0,40,4,114,128,1,31,209,202,0,
-+6,126,73,65,245,28,160,0,135,196,114,128,2,158,209,202,0,12,122,71,40,0,57,
-+229,28,160,1,7,132,85,227,186,50,241,217,37,32,0,39,84,128,29,17,202,0,18,
-+115,71,40,0,81,201,28,160,1,103,20,114,128,6,7,255,224,4,195,63,65,193,1,
-+130,255,248,0,11,255,224,0,31,255,138,52,128,0,0,0,1,1,219,134,128,3,57,
-+192,71,72,4,229,0,29,99,140,201,72,50,31,32,196,144,131,2,49,225,121,16,
-+240,184,132,120,82,64,65,102,252,0,233,239,200,20,62,176,78,248,0,255,148,
-+0,5,163,240,0,15,249,192,9,242,38,16,0,23,184,152,5,171,240,0,15,250,64,9,
-+242,200,16,0,23,187,32,5,179,240,0,15,250,194,15,72,0,0,0,0,0,0,0,64,15,
-+201,4,195,187,126,226,4,200,68,18,162,16,72,134,60,35,67,31,0,1,25,161,143,
-+128,1,8,144,199,192,0,196,40,99,224,0,130,4,49,240,0,84,255,252,36,100,16,
-+184,155,250,226,217,150,47,46,91,249,34,224,139,229,229,203,127,36,26,119,
-+32,203,203,150,254,72,52,97,221,147,102,157,217,192,
-+};
-+#ifdef DUK_USE_BUILTIN_INITJS
-+DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = {
-+40,102,117,110,99,116,105,111,110,40,100,44,97,41,123,102,117,110,99,116,
-+105,111,110,32,98,40,97,44,98,44,99,41,123,79,98,106,101,99,116,46,100,101,
-+102,105,110,101,80,114,111,112,101,114,116,121,40,97,44,98,44,123,118,97,
-+108,117,101,58,99,44,119,114,105,116,97,98,108,101,58,33,48,44,101,110,117,
-+109,101,114,97,98,108,101,58,33,49,44,99,111,110,102,105,103,117,114,97,98,
-+108,101,58,33,48,125,41,125,98,40,97,46,76,111,103,103,101,114,44,34,99,
-+108,111,103,34,44,110,101,119,32,97,46,76,111,103,103,101,114,40,34,67,34,
-+41,41,59,98,40,97,44,34,109,111,100,76,111,97,100,101,100,34,44,123,125,41,
-+125,41,40,116,104,105,115,44,68,117,107,116,97,112,101,41,59,10,0,
-+};
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+#elif defined(DUK_USE_DOUBLE_BE)
-+DUK_INTERNAL const duk_uint8_t duk_strings_data[1943] = {
-+55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,26,20,164,137,
-+186,50,11,164,109,77,215,5,61,35,106,3,25,110,8,22,158,130,38,163,8,217,
-+200,158,76,156,210,117,128,153,203,210,70,46,137,187,18,27,164,187,201,209,
-+130,100,55,91,70,4,145,63,66,231,44,128,105,187,41,197,13,49,122,8,196,24,
-+71,75,70,138,104,115,77,215,5,36,20,201,214,209,107,79,104,209,144,168,105,
-+6,207,251,209,104,209,125,212,227,66,127,235,191,239,232,180,90,52,95,69,
-+247,83,141,9,255,174,255,191,162,211,80,210,253,23,221,78,52,39,254,183,
-+254,254,139,72,105,126,139,238,167,26,19,255,91,255,127,69,166,129,191,69,
-+247,83,141,9,255,175,255,191,162,213,26,50,23,232,190,234,113,161,63,245,
-+115,119,86,227,118,83,138,26,98,9,110,48,86,22,148,160,152,22,82,70,46,137,
-+44,8,180,163,32,104,98,206,32,17,7,16,88,101,100,206,42,70,36,108,205,18,
-+74,140,33,196,230,60,2,152,146,33,38,230,8,36,79,182,251,65,156,151,24,200,
-+33,145,162,25,80,209,24,67,0,166,68,52,174,61,73,25,33,205,25,27,84,177,
-+195,234,220,1,144,105,99,135,217,16,17,17,208,72,199,179,60,93,100,146,49,
-+232,162,64,76,135,19,152,244,44,136,223,98,67,4,18,33,247,217,158,36,0,209,
-+190,156,13,26,201,21,111,165,67,64,180,100,145,62,250,32,45,100,33,55,214,
-+1,229,223,65,19,72,187,236,206,137,35,125,120,190,201,104,105,15,190,201,
-+212,136,136,125,246,160,137,27,83,239,171,37,200,218,159,125,168,34,192,61,
-+27,233,93,22,1,114,78,250,28,76,130,112,200,93,245,164,188,207,190,204,17,
-+49,38,109,246,160,93,8,119,185,13,153,34,96,208,165,36,85,190,206,32,17,6,
-+9,129,75,67,73,214,209,129,36,80,84,44,157,104,24,65,60,69,148,192,37,59,
-+179,60,93,110,207,15,39,73,24,186,39,232,232,169,129,228,18,6,120,146,20,
-+68,72,157,105,241,116,221,173,58,68,159,95,23,77,211,195,201,215,20,238,
-+179,122,162,98,73,35,104,194,68,19,35,134,69,146,100,235,226,231,146,51,
-+192,206,9,23,175,139,175,131,8,11,89,8,206,161,181,2,208,63,160,232,193,50,
-+23,246,254,187,235,190,187,247,69,241,95,18,31,160,15,214,11,235,126,192,
-+95,87,246,1,251,4,253,111,80,210,161,168,158,19,245,125,67,74,134,162,120,
-+71,80,210,161,168,158,12,224,164,130,153,165,56,161,166,51,104,192,146,39,
-+11,156,178,1,169,163,70,66,161,164,26,101,56,161,166,65,112,57,129,164,148,
-+35,49,201,13,44,93,70,140,209,3,70,230,13,238,176,216,134,141,128,184,214,
-+227,20,171,115,162,50,93,227,19,164,65,17,11,40,38,6,253,145,1,48,52,128,
-+146,26,64,9,210,24,3,34,250,80,140,254,200,254,148,35,63,177,215,217,11,
-+207,65,188,183,27,236,126,192,133,242,220,111,178,32,252,182,253,145,60,
-+182,253,143,216,7,164,59,9,41,0,196,35,64,194,21,13,125,38,84,52,100,185,
-+62,163,239,254,235,234,82,176,74,125,67,70,75,165,148,92,208,180,52,138,65,
-+154,232,147,162,4,136,105,58,145,17,9,50,74,100,37,200,37,205,222,51,39,47,
-+78,40,105,143,34,79,184,32,34,115,18,125,193,1,19,77,222,76,156,213,205,
-+222,68,157,47,78,40,105,151,55,122,147,20,189,56,161,166,116,137,63,82,98,
-+47,168,181,247,4,4,87,34,79,165,162,215,220,16,17,92,137,63,82,98,103,156,
-+217,157,18,36,250,199,54,103,84,137,63,82,98,31,129,50,30,68,159,70,9,145,
-+114,36,253,73,136,254,117,35,36,72,147,233,221,72,201,178,36,253,73,137,
-+158,67,105,50,73,82,36,250,196,54,147,36,155,34,79,212,152,165,226,9,205,
-+28,149,34,79,178,32,156,209,202,82,36,253,73,137,158,66,214,137,16,78,104,
-+228,249,18,125,98,22,180,72,130,115,71,35,200,147,236,208,194,68,196,159,
-+102,134,19,46,105,58,226,150,68,156,140,73,250,147,19,60,133,173,18,32,156,
-+209,201,230,36,250,196,45,104,145,4,230,142,77,49,39,234,76,82,241,4,230,
-+142,74,49,39,217,16,78,104,228,211,18,126,164,196,207,33,180,153,36,163,18,
-+125,98,27,73,146,75,49,39,234,76,71,243,169,25,32,196,159,78,234,70,73,49,
-+39,234,76,67,240,48,99,18,125,24,48,163,18,126,164,196,63,2,100,57,137,62,
-+140,19,34,204,73,250,147,19,60,230,204,232,49,39,214,57,179,59,140,73,250,
-+147,17,125,69,175,184,32,34,179,18,125,45,22,190,224,128,137,204,73,246,
-+104,97,37,55,117,110,16,22,78,205,12,39,101,56,161,166,148,221,213,184,64,
-+89,58,48,76,157,148,226,134,153,147,119,102,134,19,178,156,80,211,50,110,
-+232,193,50,118,83,138,26,97,181,214,31,169,49,21,224,140,136,185,187,175,
-+137,4,137,33,205,108,221,210,93,238,105,27,52,1,103,155,186,84,92,131,143,
-+158,233,34,104,169,52,134,149,13,68,241,31,52,134,4,209,82,105,13,42,26,
-+137,224,125,104,58,212,249,136,110,170,5,208,137,243,1,125,84,11,161,13,42,
-+6,83,137,39,20,50,51,119,86,225,1,100,237,30,242,71,162,4,136,185,187,180,
-+123,201,30,136,18,36,102,238,173,194,2,201,213,186,196,143,68,9,17,115,119,
-+86,235,18,61,16,36,68,202,129,148,226,134,152,178,122,209,51,72,128,136,
-+142,120,145,235,0,136,86,2,98,59,86,225,1,100,232,156,199,130,36,80,142,8,
-+244,78,25,58,9,152,71,4,122,9,176,177,115,58,35,130,61,19,134,69,196,131,
-+160,137,216,160,199,153,162,65,208,68,49,80,185,146,35,96,30,114,186,61,32,
-+4,114,73,204,33,73,82,71,11,88,37,62,161,163,37,250,226,157,13,25,47,215,
-+20,244,108,142,130,204,210,122,208,34,18,78,140,203,37,160,68,44,142,130,
-+204,241,37,73,25,16,143,164,142,55,185,228,75,144,211,9,205,16,38,116,75,
-+160,140,65,132,130,38,163,8,217,200,194,2,214,72,144,40,104,200,32,45,101,
-+3,222,188,81,241,115,201,25,227,168,151,72,218,48,145,0,86,70,162,93,124,
-+93,55,79,15,39,92,87,28,18,235,172,222,190,46,121,35,60,30,160,93,9,215,21,
-+211,119,86,225,1,100,236,167,20,52,200,155,187,41,197,13,50,196,230,202,
-+113,160,166,232,142,68,152,204,73,168,141,163,9,16,5,100,96,156,210,160,
-+212,136,2,178,34,209,68,192,21,144,181,2,232,66,40,152,147,17,46,146,243,
-+35,100,128,172,136,68,186,88,187,36,106,17,46,200,128,89,7,23,196,149,35,
-+103,210,94,100,108,144,230,200,197,137,9,146,18,68,2,224,50,21,13,39,95,23,
-+60,145,154,9,39,12,133,67,73,215,197,207,36,103,131,10,36,4,201,51,18,125,
-+117,155,215,197,207,36,103,142,180,12,36,176,98,79,174,179,122,248,185,228,
-+140,241,209,146,66,138,31,55,69,198,36,250,248,186,110,158,30,78,184,169,
-+124,93,55,79,15,33,150,70,154,103,40,22,72,204,175,138,27,52,81,164,144,
-+128,242,24,146,16,30,73,17,162,112,201,234,69,2,243,152,247,52,141,154,72,
-+209,56,100,245,34,137,12,130,112,201,234,69,2,243,152,247,52,141,154,70,65,
-+56,100,245,34,132,34,93,42,26,137,144,168,151,90,14,181,79,4,100,78,149,
-+110,4,208,240,70,68,234,27,50,18,160,90,61,72,160,158,140,93,20,246,120,
-+121,58,72,197,209,95,101,134,204,23,233,35,23,69,221,137,10,72,145,162,39,
-+73,24,186,42,236,64,211,19,164,140,93,20,244,149,2,250,72,197,209,40,98,64,
-+40,130,4,136,81,2,98,58,4,230,205,13,161,16,50,6,134,49,34,113,144,160,162,
-+230,97,145,100,153,4,55,16,139,145,14,84,52,11,94,6,87,69,5,163,69,52,57,
-+162,65,68,134,169,13,148,192,209,17,197,27,73,99,68,147,164,90,105,89,19,
-+17,201,51,162,69,153,226,235,14,113,193,167,135,145,197,29,65,18,85,200,25,
-+108,116,44,132,178,38,114,137,96,148,138,39,54,83,33,27,70,24,151,123,163,
-+51,146,243,35,71,35,33,143,116,102,89,81,228,137,27,69,172,147,141,8,82,
-+129,114,34,144,199,172,140,35,103,36,161,179,36,74,1,16,107,36,206,240,9,
-+64,49,14,248,162,160,153,18,248,186,100,20,200,51,62,129,90,4,105,76,19,64,
-+139,132,17,99,
-+};
-+
-+/* to convert a heap stridx to a token number, subtract
-+ * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED.
-+ */
-+
-+/* native functions: 128 */
-+DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = {
-+	duk_bi_array_constructor,
-+	duk_bi_array_constructor_is_array,
-+	duk_bi_array_prototype_concat,
-+	duk_bi_array_prototype_indexof_shared,
-+	duk_bi_array_prototype_iter_shared,
-+	duk_bi_array_prototype_join_shared,
-+	duk_bi_array_prototype_pop,
-+	duk_bi_array_prototype_push,
-+	duk_bi_array_prototype_reduce_shared,
-+	duk_bi_array_prototype_reverse,
-+	duk_bi_array_prototype_shift,
-+	duk_bi_array_prototype_slice,
-+	duk_bi_array_prototype_sort,
-+	duk_bi_array_prototype_splice,
-+	duk_bi_array_prototype_to_string,
-+	duk_bi_array_prototype_unshift,
-+	duk_bi_boolean_constructor,
-+	duk_bi_boolean_prototype_tostring_shared,
-+	duk_bi_buffer_constructor,
-+	duk_bi_buffer_prototype_tostring_shared,
-+	duk_bi_date_constructor,
-+	duk_bi_date_constructor_now,
-+	duk_bi_date_constructor_parse,
-+	duk_bi_date_constructor_utc,
-+	duk_bi_date_prototype_get_shared,
-+	duk_bi_date_prototype_get_timezone_offset,
-+	duk_bi_date_prototype_set_shared,
-+	duk_bi_date_prototype_set_time,
-+	duk_bi_date_prototype_to_json,
-+	duk_bi_date_prototype_tostring_shared,
-+	duk_bi_date_prototype_value_of,
-+	duk_bi_duktape_object_act,
-+	duk_bi_duktape_object_compact,
-+	duk_bi_duktape_object_dec,
-+	duk_bi_duktape_object_enc,
-+	duk_bi_duktape_object_fin,
-+	duk_bi_duktape_object_gc,
-+	duk_bi_duktape_object_info,
-+	duk_bi_error_constructor_shared,
-+	duk_bi_error_prototype_filename_getter,
-+	duk_bi_error_prototype_linenumber_getter,
-+	duk_bi_error_prototype_nop_setter,
-+	duk_bi_error_prototype_stack_getter,
-+	duk_bi_error_prototype_to_string,
-+	duk_bi_function_constructor,
-+	duk_bi_function_prototype,
-+	duk_bi_function_prototype_apply,
-+	duk_bi_function_prototype_bind,
-+	duk_bi_function_prototype_call,
-+	duk_bi_function_prototype_to_string,
-+	duk_bi_global_object_decode_uri,
-+	duk_bi_global_object_decode_uri_component,
-+	duk_bi_global_object_encode_uri,
-+	duk_bi_global_object_encode_uri_component,
-+	duk_bi_global_object_escape,
-+	duk_bi_global_object_eval,
-+	duk_bi_global_object_is_finite,
-+	duk_bi_global_object_is_nan,
-+	duk_bi_global_object_parse_float,
-+	duk_bi_global_object_parse_int,
-+	duk_bi_global_object_print_helper,
-+	duk_bi_global_object_require,
-+	duk_bi_global_object_unescape,
-+	duk_bi_json_object_parse,
-+	duk_bi_json_object_stringify,
-+	duk_bi_logger_constructor,
-+	duk_bi_logger_prototype_fmt,
-+	duk_bi_logger_prototype_log_shared,
-+	duk_bi_logger_prototype_raw,
-+	duk_bi_math_object_max,
-+	duk_bi_math_object_min,
-+	duk_bi_math_object_onearg_shared,
-+	duk_bi_math_object_random,
-+	duk_bi_math_object_twoarg_shared,
-+	duk_bi_number_constructor,
-+	duk_bi_number_prototype_to_exponential,
-+	duk_bi_number_prototype_to_fixed,
-+	duk_bi_number_prototype_to_locale_string,
-+	duk_bi_number_prototype_to_precision,
-+	duk_bi_number_prototype_to_string,
-+	duk_bi_number_prototype_value_of,
-+	duk_bi_object_constructor,
-+	duk_bi_object_constructor_create,
-+	duk_bi_object_constructor_define_properties,
-+	duk_bi_object_constructor_define_property,
-+	duk_bi_object_constructor_get_own_property_descriptor,
-+	duk_bi_object_constructor_is_extensible,
-+	duk_bi_object_constructor_is_sealed_frozen_shared,
-+	duk_bi_object_constructor_keys_shared,
-+	duk_bi_object_constructor_prevent_extensions,
-+	duk_bi_object_constructor_seal_freeze_shared,
-+	duk_bi_object_getprototype_shared,
-+	duk_bi_object_prototype_has_own_property,
-+	duk_bi_object_prototype_is_prototype_of,
-+	duk_bi_object_prototype_property_is_enumerable,
-+	duk_bi_object_prototype_to_locale_string,
-+	duk_bi_object_prototype_to_string,
-+	duk_bi_object_prototype_value_of,
-+	duk_bi_object_setprototype_shared,
-+	duk_bi_pointer_constructor,
-+	duk_bi_pointer_prototype_tostring_shared,
-+	duk_bi_proxy_constructor,
-+	duk_bi_regexp_constructor,
-+	duk_bi_regexp_prototype_exec,
-+	duk_bi_regexp_prototype_test,
-+	duk_bi_regexp_prototype_to_string,
-+	duk_bi_string_constructor,
-+	duk_bi_string_constructor_from_char_code,
-+	duk_bi_string_prototype_caseconv_shared,
-+	duk_bi_string_prototype_char_at,
-+	duk_bi_string_prototype_char_code_at,
-+	duk_bi_string_prototype_concat,
-+	duk_bi_string_prototype_indexof_shared,
-+	duk_bi_string_prototype_locale_compare,
-+	duk_bi_string_prototype_match,
-+	duk_bi_string_prototype_replace,
-+	duk_bi_string_prototype_search,
-+	duk_bi_string_prototype_slice,
-+	duk_bi_string_prototype_split,
-+	duk_bi_string_prototype_substr,
-+	duk_bi_string_prototype_substring,
-+	duk_bi_string_prototype_to_string,
-+	duk_bi_string_prototype_trim,
-+	duk_bi_thread_constructor,
-+	duk_bi_thread_current,
-+	duk_bi_thread_resume,
-+	duk_bi_thread_yield,
-+	duk_bi_type_error_thrower,
-+};
-+
-+DUK_INTERNAL const duk_uint8_t duk_builtins_data[1341] = {
-+105,195,74,136,77,40,105,44,9,124,104,45,3,3,72,0,71,225,65,165,168,33,243,
-+6,145,0,122,24,210,148,14,249,35,120,160,55,226,13,76,192,196,177,164,152,
-+22,192,4,202,52,147,72,152,0,169,70,146,105,11,0,23,40,210,77,32,96,3,37,
-+26,73,163,236,0,108,163,73,52,121,128,14,148,105,38,142,176,1,242,144,56,
-+208,254,84,6,166,82,242,80,210,246,1,250,67,72,144,15,232,13,44,96,47,162,
-+52,160,128,62,80,160,255,253,102,76,7,255,128,0,0,0,0,0,3,84,7,255,0,0,0,0,
-+0,0,3,124,64,153,132,18,49,2,38,48,64,200,7,153,64,227,48,26,103,3,13,0,89,
-+165,34,53,36,38,180,128,216,143,155,81,227,114,58,111,2,142,0,73,194,94,56,
-+202,167,33,209,195,114,70,206,209,26,58,36,100,228,145,131,130,69,204,137,
-+22,51,36,84,208,145,67,82,68,205,137,18,62,36,68,240,122,32,120,62,0,2,87,
-+61,39,255,254,9,46,24,0,10,31,224,29,13,91,40,0,9,101,137,32,0,48,197,84,
-+66,214,9,10,82,68,37,81,144,133,52,65,214,137,6,90,40,0,12,21,100,144,69,
-+114,64,213,202,0,3,2,86,36,5,96,160,0,63,254,16,37,135,91,98,25,242,192,7,
-+194,248,30,236,32,123,46,17,234,186,71,162,241,5,23,240,0,15,241,1,70,74,3,
-+8,249,49,3,204,185,15,35,3,231,137,121,240,163,254,0,46,224,18,7,248,192,
-+42,249,14,3,224,20,32,0,46,208,35,231,96,41,29,96,192,117,3,159,58,66,64,
-+232,10,3,156,45,14,96,194,57,67,87,156,129,231,206,48,51,240,0,23,16,25,
-+255,255,251,132,16,209,192,8,106,0,2,223,4,53,0,2,111,2,26,128,1,183,65,13,
-+64,1,27,129,7,224,0,45,176,131,255,255,241,73,252,0,91,77,103,193,254,64,
-+36,200,64,101,31,47,32,123,188,129,178,218,70,195,113,29,173,231,206,55,3,
-+71,19,129,168,0,11,93,196,141,103,34,53,92,208,212,116,35,157,213,13,55,
-+100,52,158,16,209,108,3,65,176,12,246,192,128,0,179,155,2,0,2,205,122,3,49,
-+221,2,151,248,0,7,249,64,147,35,4,249,17,8,0,11,220,68,2,155,248,172,184,
-+15,253,255,255,255,255,255,255,236,168,0,0,0,0,0,0,0,0,44,152,15,255,0,0,0,
-+0,0,0,12,120,15,254,0,0,0,0,0,0,12,136,31,254,0,0,0,0,0,0,0,7,249,128,147,
-+32,0,0,0,0,0,0,0,0,12,249,79,35,225,52,143,117,0,49,147,8,197,75,35,17,56,
-+130,159,248,1,176,197,136,194,23,254,96,138,128,63,206,4,153,33,255,224,0,
-+0,0,0,0,2,215,200,232,24,3,161,0,1,95,142,132,0,9,240,58,16,0,53,240,232,
-+64,1,23,163,161,0,5,77,142,132,0,25,52,58,16,0,116,200,225,30,227,192,94,
-+15,1,118,48,16,0,133,208,192,64,2,87,35,1,0,10,92,12,4,0,45,110,48,16,0,
-+197,176,192,64,3,86,163,1,0,14,90,12,4,0,61,102,48,16,1,5,144,192,64,4,86,
-+35,1,0,18,88,12,4,0,77,94,48,16,1,69,112,192,64,5,85,163,1,0,22,86,12,4,0,
-+93,86,50,5,80,217,21,35,69,0,24,84,13,20,0,101,78,52,190,0,52,166,26,95,0,
-+27,82,141,63,128,14,41,6,159,192,7,84,99,83,224,3,202,33,169,240,1,245,8,
-+209,64,8,20,3,69,0,33,79,141,47,128,17,39,134,151,192,8,211,163,79,224,4,
-+137,193,167,240,2,84,192,192,64,9,146,227,69,0,39,21,31,192,0,63,208,24,
-+147,4,12,0,32,41,56,72,240,60,100,148,100,140,100,132,128,0,0,0,0,0,0,0,0,
-+210,172,228,74,52,17,242,210,1,83,252,0,3,253,33,81,132,11,69,144,24,166,
-+229,69,37,23,39,41,40,57,65,72,47,146,176,10,175,224,0,159,234,4,140,41,18,
-+44,128,192,10,191,224,0,159,235,4,140,41,10,44,128,192,10,207,224,0,159,
-+236,4,140,41,2,44,128,192,10,223,224,0,159,237,4,140,40,250,44,128,192,10,
-+239,224,0,159,238,4,140,40,242,44,128,192,10,255,224,0,159,239,4,140,40,
-+234,44,128,192,7,255,228,34,160,32,2,223,133,69,138,43,180,162,96,32,1,53,
-+216,221,218,170,139,34,32,31,243,23,33,127,125,28,247,161,224,31,251,138,
-+163,178,149,193,127,33,160,31,237,229,189,138,147,114,135,33,96,32,4,144,
-+253,170,34,22,140,33,32,31,243,80,79,51,63,157,230,160,224,31,251,80,79,51,
-+63,157,230,164,130,71,34,5,28,160,0,40,4,114,128,1,31,209,202,0,6,126,73,
-+65,245,28,160,0,135,196,114,128,2,158,209,202,0,12,122,71,40,0,57,229,28,
-+160,1,7,132,85,227,186,50,241,217,37,32,0,39,84,128,29,17,202,0,18,115,71,
-+40,0,81,201,28,160,1,103,20,114,128,6,7,255,224,4,195,63,65,193,1,130,255,
-+248,0,11,255,224,0,31,255,138,52,128,129,135,219,0,0,0,0,0,3,57,192,71,72,
-+4,229,0,29,99,140,201,72,50,31,32,196,144,131,2,49,225,121,16,240,184,132,
-+120,82,64,65,102,252,0,233,239,200,20,62,176,78,248,0,255,148,0,5,163,240,
-+0,15,249,192,9,242,38,16,0,23,184,152,5,171,240,0,15,250,64,9,242,200,16,0,
-+23,187,32,5,179,240,0,15,250,194,15,72,64,0,0,0,0,0,0,0,15,201,4,195,187,
-+126,226,4,200,68,18,162,16,72,134,60,35,67,31,0,1,25,161,143,128,1,8,144,
-+199,192,0,196,40,99,224,0,130,4,49,240,0,84,255,252,36,100,16,184,155,250,
-+226,217,150,47,46,91,249,34,224,139,229,229,203,127,36,26,119,32,203,203,
-+150,254,72,52,97,221,147,102,157,217,192,
-+};
-+#ifdef DUK_USE_BUILTIN_INITJS
-+DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = {
-+40,102,117,110,99,116,105,111,110,40,100,44,97,41,123,102,117,110,99,116,
-+105,111,110,32,98,40,97,44,98,44,99,41,123,79,98,106,101,99,116,46,100,101,
-+102,105,110,101,80,114,111,112,101,114,116,121,40,97,44,98,44,123,118,97,
-+108,117,101,58,99,44,119,114,105,116,97,98,108,101,58,33,48,44,101,110,117,
-+109,101,114,97,98,108,101,58,33,49,44,99,111,110,102,105,103,117,114,97,98,
-+108,101,58,33,48,125,41,125,98,40,97,46,76,111,103,103,101,114,44,34,99,
-+108,111,103,34,44,110,101,119,32,97,46,76,111,103,103,101,114,40,34,67,34,
-+41,41,59,98,40,97,44,34,109,111,100,76,111,97,100,101,100,34,44,123,125,41,
-+125,41,40,116,104,105,115,44,68,117,107,116,97,112,101,41,59,10,0,
-+};
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+#elif defined(DUK_USE_DOUBLE_ME)
-+DUK_INTERNAL const duk_uint8_t duk_strings_data[1943] = {
-+55,86,227,24,145,55,102,120,144,3,63,94,228,54,100,137,186,26,20,164,137,
-+186,50,11,164,109,77,215,5,61,35,106,3,25,110,8,22,158,130,38,163,8,217,
-+200,158,76,156,210,117,128,153,203,210,70,46,137,187,18,27,164,187,201,209,
-+130,100,55,91,70,4,145,63,66,231,44,128,105,187,41,197,13,49,122,8,196,24,
-+71,75,70,138,104,115,77,215,5,36,20,201,214,209,107,79,104,209,144,168,105,
-+6,207,251,209,104,209,125,212,227,66,127,235,191,239,232,180,90,52,95,69,
-+247,83,141,9,255,174,255,191,162,211,80,210,253,23,221,78,52,39,254,183,
-+254,254,139,72,105,126,139,238,167,26,19,255,91,255,127,69,166,129,191,69,
-+247,83,141,9,255,175,255,191,162,213,26,50,23,232,190,234,113,161,63,245,
-+115,119,86,227,118,83,138,26,98,9,110,48,86,22,148,160,152,22,82,70,46,137,
-+44,8,180,163,32,104,98,206,32,17,7,16,88,101,100,206,42,70,36,108,205,18,
-+74,140,33,196,230,60,2,152,146,33,38,230,8,36,79,182,251,65,156,151,24,200,
-+33,145,162,25,80,209,24,67,0,166,68,52,174,61,73,25,33,205,25,27,84,177,
-+195,234,220,1,144,105,99,135,217,16,17,17,208,72,199,179,60,93,100,146,49,
-+232,162,64,76,135,19,152,244,44,136,223,98,67,4,18,33,247,217,158,36,0,209,
-+190,156,13,26,201,21,111,165,67,64,180,100,145,62,250,32,45,100,33,55,214,
-+1,229,223,65,19,72,187,236,206,137,35,125,120,190,201,104,105,15,190,201,
-+212,136,136,125,246,160,137,27,83,239,171,37,200,218,159,125,168,34,192,61,
-+27,233,93,22,1,114,78,250,28,76,130,112,200,93,245,164,188,207,190,204,17,
-+49,38,109,246,160,93,8,119,185,13,153,34,96,208,165,36,85,190,206,32,17,6,
-+9,129,75,67,73,214,209,129,36,80,84,44,157,104,24,65,60,69,148,192,37,59,
-+179,60,93,110,207,15,39,73,24,186,39,232,232,169,129,228,18,6,120,146,20,
-+68,72,157,105,241,116,221,173,58,68,159,95,23,77,211,195,201,215,20,238,
-+179,122,162,98,73,35,104,194,68,19,35,134,69,146,100,235,226,231,146,51,
-+192,206,9,23,175,139,175,131,8,11,89,8,206,161,181,2,208,63,160,232,193,50,
-+23,246,254,187,235,190,187,247,69,241,95,18,31,160,15,214,11,235,126,192,
-+95,87,246,1,251,4,253,111,80,210,161,168,158,19,245,125,67,74,134,162,120,
-+71,80,210,161,168,158,12,224,164,130,153,165,56,161,166,51,104,192,146,39,
-+11,156,178,1,169,163,70,66,161,164,26,101,56,161,166,65,112,57,129,164,148,
-+35,49,201,13,44,93,70,140,209,3,70,230,13,238,176,216,134,141,128,184,214,
-+227,20,171,115,162,50,93,227,19,164,65,17,11,40,38,6,253,145,1,48,52,128,
-+146,26,64,9,210,24,3,34,250,80,140,254,200,254,148,35,63,177,215,217,11,
-+207,65,188,183,27,236,126,192,133,242,220,111,178,32,252,182,253,145,60,
-+182,253,143,216,7,164,59,9,41,0,196,35,64,194,21,13,125,38,84,52,100,185,
-+62,163,239,254,235,234,82,176,74,125,67,70,75,165,148,92,208,180,52,138,65,
-+154,232,147,162,4,136,105,58,145,17,9,50,74,100,37,200,37,205,222,51,39,47,
-+78,40,105,143,34,79,184,32,34,115,18,125,193,1,19,77,222,76,156,213,205,
-+222,68,157,47,78,40,105,151,55,122,147,20,189,56,161,166,116,137,63,82,98,
-+47,168,181,247,4,4,87,34,79,165,162,215,220,16,17,92,137,63,82,98,103,156,
-+217,157,18,36,250,199,54,103,84,137,63,82,98,31,129,50,30,68,159,70,9,145,
-+114,36,253,73,136,254,117,35,36,72,147,233,221,72,201,178,36,253,73,137,
-+158,67,105,50,73,82,36,250,196,54,147,36,155,34,79,212,152,165,226,9,205,
-+28,149,34,79,178,32,156,209,202,82,36,253,73,137,158,66,214,137,16,78,104,
-+228,249,18,125,98,22,180,72,130,115,71,35,200,147,236,208,194,68,196,159,
-+102,134,19,46,105,58,226,150,68,156,140,73,250,147,19,60,133,173,18,32,156,
-+209,201,230,36,250,196,45,104,145,4,230,142,77,49,39,234,76,82,241,4,230,
-+142,74,49,39,217,16,78,104,228,211,18,126,164,196,207,33,180,153,36,163,18,
-+125,98,27,73,146,75,49,39,234,76,71,243,169,25,32,196,159,78,234,70,73,49,
-+39,234,76,67,240,48,99,18,125,24,48,163,18,126,164,196,63,2,100,57,137,62,
-+140,19,34,204,73,250,147,19,60,230,204,232,49,39,214,57,179,59,140,73,250,
-+147,17,125,69,175,184,32,34,179,18,125,45,22,190,224,128,137,204,73,246,
-+104,97,37,55,117,110,16,22,78,205,12,39,101,56,161,166,148,221,213,184,64,
-+89,58,48,76,157,148,226,134,153,147,119,102,134,19,178,156,80,211,50,110,
-+232,193,50,118,83,138,26,97,181,214,31,169,49,21,224,140,136,185,187,175,
-+137,4,137,33,205,108,221,210,93,238,105,27,52,1,103,155,186,84,92,131,143,
-+158,233,34,104,169,52,134,149,13,68,241,31,52,134,4,209,82,105,13,42,26,
-+137,224,125,104,58,212,249,136,110,170,5,208,137,243,1,125,84,11,161,13,42,
-+6,83,137,39,20,50,51,119,86,225,1,100,237,30,242,71,162,4,136,185,187,180,
-+123,201,30,136,18,36,102,238,173,194,2,201,213,186,196,143,68,9,17,115,119,
-+86,235,18,61,16,36,68,202,129,148,226,134,152,178,122,209,51,72,128,136,
-+142,120,145,235,0,136,86,2,98,59,86,225,1,100,232,156,199,130,36,80,142,8,
-+244,78,25,58,9,152,71,4,122,9,176,177,115,58,35,130,61,19,134,69,196,131,
-+160,137,216,160,199,153,162,65,208,68,49,80,185,146,35,96,30,114,186,61,32,
-+4,114,73,204,33,73,82,71,11,88,37,62,161,163,37,250,226,157,13,25,47,215,
-+20,244,108,142,130,204,210,122,208,34,18,78,140,203,37,160,68,44,142,130,
-+204,241,37,73,25,16,143,164,142,55,185,228,75,144,211,9,205,16,38,116,75,
-+160,140,65,132,130,38,163,8,217,200,194,2,214,72,144,40,104,200,32,45,101,
-+3,222,188,81,241,115,201,25,227,168,151,72,218,48,145,0,86,70,162,93,124,
-+93,55,79,15,39,92,87,28,18,235,172,222,190,46,121,35,60,30,160,93,9,215,21,
-+211,119,86,225,1,100,236,167,20,52,200,155,187,41,197,13,50,196,230,202,
-+113,160,166,232,142,68,152,204,73,168,141,163,9,16,5,100,96,156,210,160,
-+212,136,2,178,34,209,68,192,21,144,181,2,232,66,40,152,147,17,46,146,243,
-+35,100,128,172,136,68,186,88,187,36,106,17,46,200,128,89,7,23,196,149,35,
-+103,210,94,100,108,144,230,200,197,137,9,146,18,68,2,224,50,21,13,39,95,23,
-+60,145,154,9,39,12,133,67,73,215,197,207,36,103,131,10,36,4,201,51,18,125,
-+117,155,215,197,207,36,103,142,180,12,36,176,98,79,174,179,122,248,185,228,
-+140,241,209,146,66,138,31,55,69,198,36,250,248,186,110,158,30,78,184,169,
-+124,93,55,79,15,33,150,70,154,103,40,22,72,204,175,138,27,52,81,164,144,
-+128,242,24,146,16,30,73,17,162,112,201,234,69,2,243,152,247,52,141,154,72,
-+209,56,100,245,34,137,12,130,112,201,234,69,2,243,152,247,52,141,154,70,65,
-+56,100,245,34,132,34,93,42,26,137,144,168,151,90,14,181,79,4,100,78,149,
-+110,4,208,240,70,68,234,27,50,18,160,90,61,72,160,158,140,93,20,246,120,
-+121,58,72,197,209,95,101,134,204,23,233,35,23,69,221,137,10,72,145,162,39,
-+73,24,186,42,236,64,211,19,164,140,93,20,244,149,2,250,72,197,209,40,98,64,
-+40,130,4,136,81,2,98,58,4,230,205,13,161,16,50,6,134,49,34,113,144,160,162,
-+230,97,145,100,153,4,55,16,139,145,14,84,52,11,94,6,87,69,5,163,69,52,57,
-+162,65,68,134,169,13,148,192,209,17,197,27,73,99,68,147,164,90,105,89,19,
-+17,201,51,162,69,153,226,235,14,113,193,167,135,145,197,29,65,18,85,200,25,
-+108,116,44,132,178,38,114,137,96,148,138,39,54,83,33,27,70,24,151,123,163,
-+51,146,243,35,71,35,33,143,116,102,89,81,228,137,27,69,172,147,141,8,82,
-+129,114,34,144,199,172,140,35,103,36,161,179,36,74,1,16,107,36,206,240,9,
-+64,49,14,248,162,160,153,18,248,186,100,20,200,51,62,129,90,4,105,76,19,64,
-+139,132,17,99,
-+};
-+
-+/* to convert a heap stridx to a token number, subtract
-+ * DUK_STRIDX_START_RESERVED and add DUK_TOK_START_RESERVED.
-+ */
-+
-+/* native functions: 128 */
-+DUK_INTERNAL const duk_c_function duk_bi_native_functions[128] = {
-+	duk_bi_array_constructor,
-+	duk_bi_array_constructor_is_array,
-+	duk_bi_array_prototype_concat,
-+	duk_bi_array_prototype_indexof_shared,
-+	duk_bi_array_prototype_iter_shared,
-+	duk_bi_array_prototype_join_shared,
-+	duk_bi_array_prototype_pop,
-+	duk_bi_array_prototype_push,
-+	duk_bi_array_prototype_reduce_shared,
-+	duk_bi_array_prototype_reverse,
-+	duk_bi_array_prototype_shift,
-+	duk_bi_array_prototype_slice,
-+	duk_bi_array_prototype_sort,
-+	duk_bi_array_prototype_splice,
-+	duk_bi_array_prototype_to_string,
-+	duk_bi_array_prototype_unshift,
-+	duk_bi_boolean_constructor,
-+	duk_bi_boolean_prototype_tostring_shared,
-+	duk_bi_buffer_constructor,
-+	duk_bi_buffer_prototype_tostring_shared,
-+	duk_bi_date_constructor,
-+	duk_bi_date_constructor_now,
-+	duk_bi_date_constructor_parse,
-+	duk_bi_date_constructor_utc,
-+	duk_bi_date_prototype_get_shared,
-+	duk_bi_date_prototype_get_timezone_offset,
-+	duk_bi_date_prototype_set_shared,
-+	duk_bi_date_prototype_set_time,
-+	duk_bi_date_prototype_to_json,
-+	duk_bi_date_prototype_tostring_shared,
-+	duk_bi_date_prototype_value_of,
-+	duk_bi_duktape_object_act,
-+	duk_bi_duktape_object_compact,
-+	duk_bi_duktape_object_dec,
-+	duk_bi_duktape_object_enc,
-+	duk_bi_duktape_object_fin,
-+	duk_bi_duktape_object_gc,
-+	duk_bi_duktape_object_info,
-+	duk_bi_error_constructor_shared,
-+	duk_bi_error_prototype_filename_getter,
-+	duk_bi_error_prototype_linenumber_getter,
-+	duk_bi_error_prototype_nop_setter,
-+	duk_bi_error_prototype_stack_getter,
-+	duk_bi_error_prototype_to_string,
-+	duk_bi_function_constructor,
-+	duk_bi_function_prototype,
-+	duk_bi_function_prototype_apply,
-+	duk_bi_function_prototype_bind,
-+	duk_bi_function_prototype_call,
-+	duk_bi_function_prototype_to_string,
-+	duk_bi_global_object_decode_uri,
-+	duk_bi_global_object_decode_uri_component,
-+	duk_bi_global_object_encode_uri,
-+	duk_bi_global_object_encode_uri_component,
-+	duk_bi_global_object_escape,
-+	duk_bi_global_object_eval,
-+	duk_bi_global_object_is_finite,
-+	duk_bi_global_object_is_nan,
-+	duk_bi_global_object_parse_float,
-+	duk_bi_global_object_parse_int,
-+	duk_bi_global_object_print_helper,
-+	duk_bi_global_object_require,
-+	duk_bi_global_object_unescape,
-+	duk_bi_json_object_parse,
-+	duk_bi_json_object_stringify,
-+	duk_bi_logger_constructor,
-+	duk_bi_logger_prototype_fmt,
-+	duk_bi_logger_prototype_log_shared,
-+	duk_bi_logger_prototype_raw,
-+	duk_bi_math_object_max,
-+	duk_bi_math_object_min,
-+	duk_bi_math_object_onearg_shared,
-+	duk_bi_math_object_random,
-+	duk_bi_math_object_twoarg_shared,
-+	duk_bi_number_constructor,
-+	duk_bi_number_prototype_to_exponential,
-+	duk_bi_number_prototype_to_fixed,
-+	duk_bi_number_prototype_to_locale_string,
-+	duk_bi_number_prototype_to_precision,
-+	duk_bi_number_prototype_to_string,
-+	duk_bi_number_prototype_value_of,
-+	duk_bi_object_constructor,
-+	duk_bi_object_constructor_create,
-+	duk_bi_object_constructor_define_properties,
-+	duk_bi_object_constructor_define_property,
-+	duk_bi_object_constructor_get_own_property_descriptor,
-+	duk_bi_object_constructor_is_extensible,
-+	duk_bi_object_constructor_is_sealed_frozen_shared,
-+	duk_bi_object_constructor_keys_shared,
-+	duk_bi_object_constructor_prevent_extensions,
-+	duk_bi_object_constructor_seal_freeze_shared,
-+	duk_bi_object_getprototype_shared,
-+	duk_bi_object_prototype_has_own_property,
-+	duk_bi_object_prototype_is_prototype_of,
-+	duk_bi_object_prototype_property_is_enumerable,
-+	duk_bi_object_prototype_to_locale_string,
-+	duk_bi_object_prototype_to_string,
-+	duk_bi_object_prototype_value_of,
-+	duk_bi_object_setprototype_shared,
-+	duk_bi_pointer_constructor,
-+	duk_bi_pointer_prototype_tostring_shared,
-+	duk_bi_proxy_constructor,
-+	duk_bi_regexp_constructor,
-+	duk_bi_regexp_prototype_exec,
-+	duk_bi_regexp_prototype_test,
-+	duk_bi_regexp_prototype_to_string,
-+	duk_bi_string_constructor,
-+	duk_bi_string_constructor_from_char_code,
-+	duk_bi_string_prototype_caseconv_shared,
-+	duk_bi_string_prototype_char_at,
-+	duk_bi_string_prototype_char_code_at,
-+	duk_bi_string_prototype_concat,
-+	duk_bi_string_prototype_indexof_shared,
-+	duk_bi_string_prototype_locale_compare,
-+	duk_bi_string_prototype_match,
-+	duk_bi_string_prototype_replace,
-+	duk_bi_string_prototype_search,
-+	duk_bi_string_prototype_slice,
-+	duk_bi_string_prototype_split,
-+	duk_bi_string_prototype_substr,
-+	duk_bi_string_prototype_substring,
-+	duk_bi_string_prototype_to_string,
-+	duk_bi_string_prototype_trim,
-+	duk_bi_thread_constructor,
-+	duk_bi_thread_current,
-+	duk_bi_thread_resume,
-+	duk_bi_thread_yield,
-+	duk_bi_type_error_thrower,
-+};
-+
-+DUK_INTERNAL const duk_uint8_t duk_builtins_data[1341] = {
-+105,195,74,136,77,40,105,44,9,124,104,45,3,3,72,0,71,225,65,165,168,33,243,
-+6,145,0,122,24,210,148,14,249,35,120,160,55,226,13,76,192,196,177,164,152,
-+22,192,4,202,52,147,72,152,0,169,70,146,105,11,0,23,40,210,77,32,96,3,37,
-+26,73,163,236,0,108,163,73,52,121,128,14,148,105,38,142,176,1,242,144,56,
-+208,254,84,6,166,82,242,80,210,246,1,250,67,72,144,15,232,13,44,96,47,162,
-+52,160,128,62,80,160,255,253,102,76,0,0,15,135,240,0,0,0,3,84,0,0,15,7,240,
-+0,0,0,3,124,64,153,132,18,49,2,38,48,64,200,7,153,64,227,48,26,103,3,13,0,
-+89,165,34,53,36,38,180,128,216,143,155,81,227,114,58,111,2,142,0,73,194,94,
-+56,202,167,33,209,195,114,70,206,209,26,58,36,100,228,145,131,130,69,204,
-+137,22,51,36,84,208,145,67,82,68,205,137,18,62,36,68,240,122,32,120,62,0,2,
-+87,61,39,255,254,9,46,24,0,10,31,224,29,13,91,40,0,9,101,137,32,0,48,197,
-+84,66,214,9,10,82,68,37,81,144,133,52,65,214,137,6,90,40,0,12,21,100,144,
-+69,114,64,213,202,0,3,2,86,36,5,96,160,0,63,254,16,37,135,91,98,25,242,192,
-+7,194,248,30,236,32,123,46,17,234,186,71,162,241,5,23,240,0,15,241,1,70,74,
-+3,8,249,49,3,204,185,15,35,3,231,137,121,240,163,254,0,46,224,18,7,248,192,
-+42,249,14,3,224,20,32,0,46,208,35,231,96,41,29,96,192,117,3,159,58,66,64,
-+232,10,3,156,45,14,96,194,57,67,87,156,129,231,206,48,51,240,0,23,16,25,
-+255,255,251,132,16,209,192,8,106,0,2,223,4,53,0,2,111,2,26,128,1,183,65,13,
-+64,1,27,129,7,224,0,45,176,131,255,255,241,73,252,0,91,77,103,193,254,64,
-+36,200,64,101,31,47,32,123,188,129,178,218,70,195,113,29,173,231,206,55,3,
-+71,19,129,168,0,11,93,196,141,103,34,53,92,208,212,116,35,157,213,13,55,
-+100,52,158,16,209,108,3,65,176,12,246,192,128,0,179,155,2,0,2,205,122,3,49,
-+221,2,151,248,0,7,249,64,147,35,4,249,17,8,0,11,220,68,2,155,248,172,184,
-+31,255,253,239,255,255,255,255,236,168,0,0,0,0,0,32,0,0,12,152,0,0,31,15,
-+224,0,0,0,12,120,0,0,30,15,224,0,0,0,12,136,0,0,30,31,224,0,0,0,0,7,249,
-+128,147,32,0,0,0,0,0,0,0,0,12,249,79,35,225,52,143,117,0,49,147,8,197,75,
-+35,17,56,130,159,248,1,176,197,136,194,23,254,96,138,128,63,206,4,153,32,0,
-+3,225,252,0,0,0,2,215,200,232,24,3,161,0,1,95,142,132,0,9,240,58,16,0,53,
-+240,232,64,1,23,163,161,0,5,77,142,132,0,25,52,58,16,0,116,200,225,30,227,
-+192,94,15,1,118,48,16,0,133,208,192,64,2,87,35,1,0,10,92,12,4,0,45,110,48,
-+16,0,197,176,192,64,3,86,163,1,0,14,90,12,4,0,61,102,48,16,1,5,144,192,64,
-+4,86,35,1,0,18,88,12,4,0,77,94,48,16,1,69,112,192,64,5,85,163,1,0,22,86,12,
-+4,0,93,86,50,5,80,217,21,35,69,0,24,84,13,20,0,101,78,52,190,0,52,166,26,
-+95,0,27,82,141,63,128,14,41,6,159,192,7,84,99,83,224,3,202,33,169,240,1,
-+245,8,209,64,8,20,3,69,0,33,79,141,47,128,17,39,134,151,192,8,211,163,79,
-+224,4,137,193,167,240,2,84,192,192,64,9,146,227,69,0,39,21,31,192,0,63,208,
-+24,147,4,12,0,32,41,56,72,240,60,100,148,100,140,100,132,128,0,0,0,0,0,0,0,
-+0,210,172,228,74,52,17,242,210,1,83,252,0,3,253,33,81,132,11,69,144,24,166,
-+229,69,37,23,39,41,40,57,65,72,47,146,176,10,175,224,0,159,234,4,140,41,18,
-+44,128,192,10,191,224,0,159,235,4,140,41,10,44,128,192,10,207,224,0,159,
-+236,4,140,41,2,44,128,192,10,223,224,0,159,237,4,140,40,250,44,128,192,10,
-+239,224,0,159,238,4,140,40,242,44,128,192,10,255,224,0,159,239,4,140,40,
-+234,44,128,192,7,255,228,34,160,5,95,130,160,52,171,138,69,162,96,88,181,
-+129,32,11,42,218,221,162,32,33,23,115,31,247,156,253,127,33,224,35,138,251,
-+159,255,65,21,178,161,160,61,229,237,159,135,114,147,10,161,96,125,144,132,
-+160,12,22,162,42,33,32,79,80,115,31,230,157,191,179,32,224,79,80,123,31,
-+230,157,191,179,36,130,71,34,5,28,160,0,40,4,114,128,1,31,209,202,0,6,126,
-+73,65,245,28,160,0,135,196,114,128,2,158,209,202,0,12,122,71,40,0,57,229,
-+28,160,1,7,132,85,227,186,50,241,217,37,32,0,39,84,128,29,17,202,0,18,115,
-+71,40,0,81,201,28,160,1,103,20,114,128,6,7,255,224,4,195,63,65,193,1,130,
-+255,248,0,11,255,224,0,31,255,138,52,129,1,219,134,128,0,0,0,0,3,57,192,71,
-+72,4,229,0,29,99,140,201,72,50,31,32,196,144,131,2,49,225,121,16,240,184,
-+132,120,82,64,65,102,252,0,233,239,200,20,62,176,78,248,0,255,148,0,5,163,
-+240,0,15,249,192,9,242,38,16,0,23,184,152,5,171,240,0,15,250,64,9,242,200,
-+16,0,23,187,32,5,179,240,0,15,250,194,15,72,0,0,0,64,0,0,0,0,15,201,4,195,
-+187,126,226,4,200,68,18,162,16,72,134,60,35,67,31,0,1,25,161,143,128,1,8,
-+144,199,192,0,196,40,99,224,0,130,4,49,240,0,84,255,252,36,100,16,184,155,
-+250,226,217,150,47,46,91,249,34,224,139,229,229,203,127,36,26,119,32,203,
-+203,150,254,72,52,97,221,147,102,157,217,192,
-+};
-+#ifdef DUK_USE_BUILTIN_INITJS
-+DUK_INTERNAL const duk_uint8_t duk_initjs_data[187] = {
-+40,102,117,110,99,116,105,111,110,40,100,44,97,41,123,102,117,110,99,116,
-+105,111,110,32,98,40,97,44,98,44,99,41,123,79,98,106,101,99,116,46,100,101,
-+102,105,110,101,80,114,111,112,101,114,116,121,40,97,44,98,44,123,118,97,
-+108,117,101,58,99,44,119,114,105,116,97,98,108,101,58,33,48,44,101,110,117,
-+109,101,114,97,98,108,101,58,33,49,44,99,111,110,102,105,103,117,114,97,98,
-+108,101,58,33,48,125,41,125,98,40,97,46,76,111,103,103,101,114,44,34,99,
-+108,111,103,34,44,110,101,119,32,97,46,76,111,103,103,101,114,40,34,67,34,
-+41,41,59,98,40,97,44,34,109,111,100,76,111,97,100,101,100,34,44,123,125,41,
-+125,41,40,116,104,105,115,44,68,117,107,116,97,112,101,41,59,10,0,
-+};
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+#else
-+#error invalid endianness defines
-+#endif
-+#line 1 "duk_error_macros.c"
-+/*
-+ *  Error, fatal, and panic handling.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#define DUK__ERRFMT_BUFSIZE  256  /* size for formatting buffers */
-+
-+#ifdef DUK_USE_VERBOSE_ERRORS
-+
-+#ifdef DUK_USE_VARIADIC_MACROS
-+DUK_INTERNAL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) {
-+	va_list ap;
-+	char msg[DUK__ERRFMT_BUFSIZE];
-+	va_start(ap, fmt);
-+	(void) DUK_VSNPRINTF(msg, sizeof(msg), fmt, ap);
-+	msg[sizeof(msg) - 1] = (char) 0;
-+	duk_err_create_and_throw(thr, code, msg, filename, line);
-+	va_end(ap);  /* dead code, but ensures portability (see Linux man page notes) */
-+}
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+DUK_INTERNAL const char *duk_err_file_stash = NULL;
-+DUK_INTERNAL duk_int_t duk_err_line_stash = 0;
-+
-+DUK_NORETURN(DUK_LOCAL_DECL void duk__handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, va_list ap));
-+
-+DUK_LOCAL void duk__handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, va_list ap) {
-+	char msg[DUK__ERRFMT_BUFSIZE];
-+	(void) DUK_VSNPRINTF(msg, sizeof(msg), fmt, ap);
-+	msg[sizeof(msg) - 1] = (char) 0;
-+	duk_err_create_and_throw(thr, code, msg, filename, line);
-+}
-+
-+DUK_INTERNAL void duk_err_handle_error(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) {
-+	va_list ap;
-+	va_start(ap, fmt);
-+	duk__handle_error(filename, line, thr, code, fmt, ap);
-+	va_end(ap);  /* dead code */
-+}
-+
-+DUK_INTERNAL void duk_err_handle_error_stash(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) {
-+	va_list ap;
-+	va_start(ap, fmt);
-+	duk__handle_error(duk_err_file_stash, duk_err_line_stash, thr, code, fmt, ap);
-+	va_end(ap);  /* dead code */
-+}
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+#else  /* DUK_USE_VERBOSE_ERRORS */
-+
-+#ifdef DUK_USE_VARIADIC_MACROS
-+DUK_INTERNAL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code) {
-+	duk_err_create_and_throw(thr, code);
-+}
-+
-+#else  /* DUK_USE_VARIADIC_MACROS */
-+DUK_INTERNAL void duk_err_handle_error_nonverbose1(duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) {
-+	DUK_UNREF(fmt);
-+	duk_err_create_and_throw(thr, code);
-+}
-+
-+DUK_INTERNAL void duk_err_handle_error_nonverbose2(const char *filename, duk_int_t line, duk_hthread *thr, duk_errcode_t code, const char *fmt, ...) {
-+	DUK_UNREF(filename);
-+	DUK_UNREF(line);
-+	DUK_UNREF(fmt);
-+	duk_err_create_and_throw(thr, code);
-+}
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+#endif  /* DUK_USE_VERBOSE_ERRORS */
-+
-+/*
-+ *  Default fatal error handler
-+ */
-+
-+DUK_INTERNAL void duk_default_fatal_handler(duk_context *ctx, duk_errcode_t code, const char *msg) {
-+	DUK_UNREF(ctx);
-+#ifdef DUK_USE_FILE_IO
-+	DUK_FPRINTF(DUK_STDERR, "FATAL %ld: %s\n", (long) code, (const char *) (msg ? msg : "null"));
-+	DUK_FFLUSH(DUK_STDERR);
-+#else
-+	/* omit print */
-+#endif
-+	DUK_D(DUK_DPRINT("default fatal handler called, code %ld -> calling DUK_PANIC()", (long) code));
-+	DUK_PANIC(code, msg);
-+	DUK_UNREACHABLE();
-+}
-+
-+/*
-+ *  Default panic handler
-+ */
-+
-+#if !defined(DUK_USE_PANIC_HANDLER)
-+DUK_INTERNAL void duk_default_panic_handler(duk_errcode_t code, const char *msg) {
-+#ifdef DUK_USE_FILE_IO
-+	DUK_FPRINTF(DUK_STDERR, "PANIC %ld: %s ("
-+#if defined(DUK_USE_PANIC_ABORT)
-+	            "calling abort"
-+#elif defined(DUK_USE_PANIC_EXIT)
-+	            "calling exit"
-+#elif defined(DUK_USE_PANIC_SEGFAULT)
-+	            "segfaulting on purpose"
-+#else
-+#error no DUK_USE_PANIC_xxx macro defined
-+#endif
-+	            ")\n", (long) code, (const char *) (msg ? msg : "null"));
-+	DUK_FFLUSH(DUK_STDERR);
-+#else
-+	/* omit print */
-+	DUK_UNREF(code);
-+	DUK_UNREF(msg);
-+#endif
-+
-+#if defined(DUK_USE_PANIC_ABORT)
-+	DUK_ABORT();
-+#elif defined(DUK_USE_PANIC_EXIT)
-+	DUK_EXIT(-1);
-+#elif defined(DUK_USE_PANIC_SEGFAULT)
-+	/* exit() afterwards to satisfy "noreturn" */
-+	DUK_CAUSE_SEGFAULT();  /* SCANBUILD: "Dereference of null pointer", normal */
-+	DUK_EXIT(-1);
-+#else
-+#error no DUK_USE_PANIC_xxx macro defined
-+#endif
-+
-+	DUK_UNREACHABLE();
-+}
-+#endif  /* !DUK_USE_PANIC_HANDLER */
-+
-+#undef DUK__ERRFMT_BUFSIZE
-+#line 1 "duk_unicode_support.c"
-+/*
-+ *  Various Unicode help functions for character classification predicates,
-+ *  case conversion, decoding, etc.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  XUTF-8 and CESU-8 encoding/decoding
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_unicode_get_xutf8_length(duk_ucodepoint_t cp) {
-+	duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
-+	if (x < 0x80UL) {
-+		/* 7 bits */
-+		return 1;
-+	} else if (x < 0x800UL) {
-+		/* 11 bits */
-+		return 2;
-+	} else if (x < 0x10000UL) {
-+		/* 16 bits */
-+		return 3;
-+	} else if (x < 0x200000UL) {
-+		/* 21 bits */
-+		return 4;
-+	} else if (x < 0x4000000UL) {
-+		/* 26 bits */
-+		return 5;
-+	} else if (x < (duk_ucodepoint_t) 0x80000000UL) {
-+		/* 31 bits */
-+		return 6;
-+	} else {
-+		/* 36 bits */
-+		return 7;
-+	}
-+}
-+
-+DUK_INTERNAL duk_uint8_t duk_unicode_xutf8_markers[7] = {
-+	0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe
-+};
-+
-+/* Encode to extended UTF-8; 'out' must have space for at least
-+ * DUK_UNICODE_MAX_XUTF8_LENGTH bytes.  Allows encoding of any
-+ * 32-bit (unsigned) codepoint.
-+ */
-+DUK_INTERNAL duk_small_int_t duk_unicode_encode_xutf8(duk_ucodepoint_t cp, duk_uint8_t *out) {
-+	duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
-+	duk_small_int_t len;
-+	duk_uint8_t marker;
-+	duk_small_int_t i;
-+
-+	len = duk_unicode_get_xutf8_length(cp);
-+	DUK_ASSERT(len > 0);
-+
-+	marker = duk_unicode_xutf8_markers[len - 1];  /* 64-bit OK because always >= 0 */
-+
-+	i = len;
-+	DUK_ASSERT(i > 0);
-+	do {
-+		i--;
-+		if (i > 0) {
-+			out[i] = (duk_uint8_t) (0x80 + (x & 0x3f));
-+			x >>= 6;
-+		} else {
-+			/* Note: masking of 'x' is not necessary because of
-+			 * range check and shifting -> no bits overlapping
-+			 * the marker should be set.
-+			 */
-+			out[0] = (duk_uint8_t) (marker + x);
-+		}
-+	} while (i > 0);
-+
-+	return len;
-+}
-+
-+/* Encode to CESU-8; 'out' must have space for at least
-+ * DUK_UNICODE_MAX_CESU8_LENGTH bytes; codepoints above U+10FFFF
-+ * will encode to garbage but won't overwrite the output buffer.
-+ */
-+DUK_INTERNAL duk_small_int_t duk_unicode_encode_cesu8(duk_ucodepoint_t cp, duk_uint8_t *out) {
-+	duk_uint_fast32_t x = (duk_uint_fast32_t) cp;
-+	duk_small_int_t len;
-+
-+	if (x < 0x80UL) {
-+		out[0] = (duk_uint8_t) x;
-+		len = 1;
-+	} else if (x < 0x800UL) {
-+		out[0] = (duk_uint8_t) (0xc0 + ((x >> 6) & 0x1f));
-+		out[1] = (duk_uint8_t) (0x80 + (x & 0x3f));
-+		len = 2;
-+	} else if (x < 0x10000UL) {
-+		/* surrogate pairs get encoded here */
-+		out[0] = (duk_uint8_t) (0xe0 + ((x >> 12) & 0x0f));
-+		out[1] = (duk_uint8_t) (0x80 + ((x >> 6) & 0x3f));
-+		out[2] = (duk_uint8_t) (0x80 + (x & 0x3f));
-+		len = 3;
-+	} else {
-+		/*
-+		 *  Unicode codepoints above U+FFFF are encoded as surrogate
-+		 *  pairs here.  This ensures that all CESU-8 codepoints are
-+		 *  16-bit values as expected in Ecmascript.  The surrogate
-+		 *  pairs always get a 3-byte encoding (each) in CESU-8.
-+		 *  See: http://en.wikipedia.org/wiki/Surrogate_pair
-+		 *
-+		 *  20-bit codepoint, 10 bits (A and B) per surrogate pair:
-+		 *
-+		 *    x = 0b00000000 0000AAAA AAAAAABB BBBBBBBB
-+		 *  sp1 = 0b110110AA AAAAAAAA  (0xd800 + ((x >> 10) & 0x3ff))
-+		 *  sp2 = 0b110111BB BBBBBBBB  (0xdc00 + (x & 0x3ff))
-+		 *
-+		 *  Encoded into CESU-8:
-+		 *
-+		 *  sp1 -> 0b11101101  (0xe0 + ((sp1 >> 12) & 0x0f))
-+		 *      -> 0b1010AAAA  (0x80 + ((sp1 >> 6) & 0x3f))
-+		 *      -> 0b10AAAAAA  (0x80 + (sp1 & 0x3f))
-+		 *  sp2 -> 0b11101101  (0xe0 + ((sp2 >> 12) & 0x0f))
-+		 *      -> 0b1011BBBB  (0x80 + ((sp2 >> 6) & 0x3f))
-+		 *      -> 0b10BBBBBB  (0x80 + (sp2 & 0x3f))
-+		 *
-+		 *  Note that 0x10000 must be subtracted first.  The code below
-+		 *  avoids the sp1, sp2 temporaries which saves around 20 bytes
-+		 *  of code.
-+		 */
-+
-+		x -= 0x10000UL;
-+
-+		out[0] = (duk_uint8_t) (0xed);
-+		out[1] = (duk_uint8_t) (0xa0 + ((x >> 16) & 0x0f));
-+		out[2] = (duk_uint8_t) (0x80 + ((x >> 10) & 0x3f));
-+		out[3] = (duk_uint8_t) (0xed);
-+		out[4] = (duk_uint8_t) (0xb0 + ((x >> 6) & 0x0f));
-+		out[5] = (duk_uint8_t) (0x80 + (x & 0x3f));
-+		len = 6;
-+	}
-+
-+	return len;
-+}
-+
-+/* Decode helper.  Return zero on error. */
-+DUK_INTERNAL duk_small_int_t duk_unicode_decode_xutf8(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_ucodepoint_t *out_cp) {
-+	const duk_uint8_t *p;
-+	duk_uint32_t res;
-+	duk_uint_fast8_t ch;
-+	duk_small_int_t n;
-+
-+	DUK_UNREF(thr);
-+
-+	p = *ptr;
-+	if (p < ptr_start || p >= ptr_end) {
-+		goto fail;
-+	}
-+
-+	/*
-+	 *  UTF-8 decoder which accepts longer than standard byte sequences.
-+	 *  This allows full 32-bit code points to be used.
-+	 */
-+
-+	ch = (duk_uint_fast8_t) (*p++);
-+	if (ch < 0x80) {
-+		/* 0xxx xxxx   [7 bits] */
-+		res = (duk_uint32_t) (ch & 0x7f);
-+		n = 0;
-+	} else if (ch < 0xc0) {
-+		/* 10xx xxxx -> invalid */
-+		goto fail;
-+	} else if (ch < 0xe0) {
-+		/* 110x xxxx   10xx xxxx   [11 bits] */
-+		res = (duk_uint32_t) (ch & 0x1f);
-+		n = 1;
-+	} else if (ch < 0xf0) {
-+		/* 1110 xxxx   10xx xxxx   10xx xxxx   [16 bits] */
-+		res = (duk_uint32_t) (ch & 0x0f);
-+		n = 2;
-+	} else if (ch < 0xf8) {
-+		/* 1111 0xxx   10xx xxxx   10xx xxxx   10xx xxxx   [21 bits] */
-+		res = (duk_uint32_t) (ch & 0x07);
-+		n = 3;
-+	} else if (ch < 0xfc) {
-+		/* 1111 10xx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   [26 bits] */
-+		res = (duk_uint32_t) (ch & 0x03);
-+		n = 4;
-+	} else if (ch < 0xfe) {
-+		/* 1111 110x   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   [31 bits] */
-+		res = (duk_uint32_t) (ch & 0x01);
-+		n = 5;
-+	} else if (ch < 0xff) {
-+		/* 1111 1110   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   [36 bits] */
-+		res = (duk_uint32_t) (0);
-+		n = 6;
-+	} else {
-+		/* 8-byte format could be:
-+		 * 1111 1111   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   10xx xxxx   [41 bits]
-+		 *
-+		 * However, this format would not have a zero bit following the
-+		 * leading one bits and would not allow 0xFF to be used as an
-+		 * "invalid xutf-8" marker for internal keys.  Further, 8-byte
-+		 * encodings (up to 41 bit code points) are not currently needed.
-+		 */
-+		goto fail;
-+	}
-+
-+	DUK_ASSERT(p >= ptr_start);  /* verified at beginning */
-+	if (p + n > ptr_end) {
-+		/* check pointer at end */
-+		goto fail;
-+	}
-+
-+	while (n > 0) {
-+		DUK_ASSERT(p >= ptr_start && p < ptr_end);
-+		res = res << 6;
-+		res += (duk_uint32_t) ((*p++) & 0x3f);
-+		n--;
-+	}
-+
-+	*ptr = p;
-+	*out_cp = res;
-+	return 1;
-+
-+ fail:
-+	return 0;
-+}
-+
-+/* used by e.g. duk_regexp_executor.c, string built-ins */
-+DUK_INTERNAL duk_ucodepoint_t duk_unicode_decode_xutf8_checked(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end) {
-+	duk_ucodepoint_t cp;
-+
-+	if (duk_unicode_decode_xutf8(thr, ptr, ptr_start, ptr_end, &cp)) {
-+		return cp;
-+	}
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "utf-8 decode failed");
-+	DUK_UNREACHABLE();
-+	return 0;
-+}
-+
-+/* (extended) utf-8 length without codepoint encoding validation, used
-+ * for string interning (should probably be inlined).
-+ */
-+DUK_INTERNAL duk_size_t duk_unicode_unvalidated_utf8_length(const duk_uint8_t *data, duk_size_t blen) {
-+	const duk_uint8_t *p = data;
-+	const duk_uint8_t *p_end = data + blen;
-+	duk_size_t clen = 0;
-+
-+	while (p < p_end) {
-+		duk_uint8_t x = *p++;
-+		if (x < 0x80 || x >= 0xc0) {
-+			/* 10xxxxxx = continuation chars (0x80...0xbf), above
-+			 * and below that initial bytes.
-+			 */
-+			clen++;
-+		}
-+	}
-+
-+	return clen;
-+}
-+
-+/*
-+ *  Unicode range matcher
-+ *
-+ *  Matches a codepoint against a packed bitstream of character ranges.
-+ *  Used for slow path Unicode matching.
-+ */
-+
-+/* Must match src/extract_chars.py, generate_match_table3(). */
-+DUK_LOCAL duk_uint32_t duk__uni_decode_value(duk_bitdecoder_ctx *bd_ctx) {
-+	duk_uint32_t t;
-+
-+	t = (duk_uint32_t) duk_bd_decode(bd_ctx, 4);
-+	if (t <= 0x0eU) {
-+		return t;
-+	}
-+	t = (duk_uint32_t) duk_bd_decode(bd_ctx, 8);
-+	if (t <= 0xfdU) {
-+		return t + 0x0f;
-+	}
-+	if (t == 0xfeU) {
-+		t = (duk_uint32_t) duk_bd_decode(bd_ctx, 12);
-+		return t + 0x0fU + 0xfeU;
-+	} else {
-+		t = (duk_uint32_t) duk_bd_decode(bd_ctx, 24);
-+		return t + 0x0fU + 0xfeU + 0x1000UL;
-+	}
-+}
-+
-+DUK_LOCAL duk_small_int_t duk__uni_range_match(const duk_uint8_t *unitab, duk_size_t unilen, duk_codepoint_t cp) {
-+	duk_bitdecoder_ctx bd_ctx;
-+	duk_codepoint_t prev_re;
-+
-+	DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
-+	bd_ctx.data = (duk_uint8_t *) unitab;
-+	bd_ctx.length = (duk_size_t) unilen;
-+
-+	prev_re = 0;
-+	for (;;) {
-+		duk_codepoint_t r1, r2;
-+		r1 = (duk_codepoint_t) duk__uni_decode_value(&bd_ctx);
-+		if (r1 == 0) {
-+			break;
-+		}
-+		r2 = (duk_codepoint_t) duk__uni_decode_value(&bd_ctx);
-+
-+		r1 = prev_re + r1;
-+		r2 = r1 + r2;
-+		prev_re = r2;
-+
-+		/* [r1,r2] is the range */
-+
-+		DUK_DDD(DUK_DDDPRINT("duk__uni_range_match: cp=%06lx range=[0x%06lx,0x%06lx]",
-+		                     (unsigned long) cp, (unsigned long) r1, (unsigned long) r2));
-+		if (cp >= r1 && cp <= r2) {
-+			return 1;
-+		}
-+	}
-+
-+	return 0;
-+}
-+
-+/*
-+ *  "WhiteSpace" production check.
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_unicode_is_whitespace(duk_codepoint_t cp) {
-+	/*
-+	 *  E5 Section 7.2 specifies six characters specifically as
-+	 *  white space:
-+	 *
-+	 *    0009;<control>;Cc;0;S;;;;;N;CHARACTER TABULATION;;;;
-+	 *    000B;<control>;Cc;0;S;;;;;N;LINE TABULATION;;;;
-+	 *    000C;<control>;Cc;0;WS;;;;;N;FORM FEED (FF);;;;
-+	 *    0020;SPACE;Zs;0;WS;;;;;N;;;;;
-+	 *    00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;;
-+	 *    FEFF;ZERO WIDTH NO-BREAK SPACE;Cf;0;BN;;;;;N;BYTE ORDER MARK;;;;
-+	 *
-+	 *  It also specifies any Unicode category 'Zs' characters as white
-+	 *  space.  These can be extracted with the "src/extract_chars.py" script.
-+	 *  Current result:
-+	 *
-+	 *    RAW OUTPUT:
-+	 *    ===========
-+	 *    0020;SPACE;Zs;0;WS;;;;;N;;;;;
-+	 *    00A0;NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;NON-BREAKING SPACE;;;;
-+	 *    1680;OGHAM SPACE MARK;Zs;0;WS;;;;;N;;;;;
-+	 *    180E;MONGOLIAN VOWEL SEPARATOR;Zs;0;WS;;;;;N;;;;;
-+	 *    2000;EN QUAD;Zs;0;WS;2002;;;;N;;;;;
-+	 *    2001;EM QUAD;Zs;0;WS;2003;;;;N;;;;;
-+	 *    2002;EN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    2003;EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    2004;THREE-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    2005;FOUR-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    2006;SIX-PER-EM SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    2007;FIGURE SPACE;Zs;0;WS;<noBreak> 0020;;;;N;;;;;
-+	 *    2008;PUNCTUATION SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    2009;THIN SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    200A;HAIR SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    202F;NARROW NO-BREAK SPACE;Zs;0;CS;<noBreak> 0020;;;;N;;;;;
-+	 *    205F;MEDIUM MATHEMATICAL SPACE;Zs;0;WS;<compat> 0020;;;;N;;;;;
-+	 *    3000;IDEOGRAPHIC SPACE;Zs;0;WS;<wide> 0020;;;;N;;;;;
-+	 *
-+	 *    RANGES:
-+	 *    =======
-+	 *    0x0020
-+	 *    0x00a0
-+	 *    0x1680
-+	 *    0x180e
-+	 *    0x2000 ... 0x200a
-+	 *    0x202f
-+	 *    0x205f
-+	 *    0x3000
-+	 *
-+	 *  A manual decoder (below) is probably most compact for this.
-+	 */
-+
-+	duk_uint_fast8_t lo;
-+	duk_uint_fast32_t hi;
-+
-+	/* cp == -1 (EOF) never matches and causes return value 0 */
-+
-+	lo = (duk_uint_fast8_t) (cp & 0xff);
-+	hi = (duk_uint_fast32_t) (cp >> 8);  /* does not fit into an uchar */
-+
-+	if (hi == 0x0000UL) {
-+		if (lo == 0x09U || lo == 0x0bU || lo == 0x0cU ||
-+		    lo == 0x20U || lo == 0xa0U) {
-+			return 1;
-+		}
-+	} else if (hi == 0x0020UL) {
-+		if (lo <= 0x0aU || lo == 0x2fU || lo == 0x5fU) {
-+			return 1;
-+		}
-+	} else if (cp == 0x1680L || cp == 0x180eL || cp == 0x3000L ||
-+	           cp == 0xfeffL) {
-+		return 1;
-+	}
-+
-+	return 0;
-+}
-+
-+/*
-+ *  "LineTerminator" production check.
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_unicode_is_line_terminator(duk_codepoint_t cp) {
-+	/*
-+	 *  E5 Section 7.3
-+	 *
-+	 *  A LineTerminatorSequence essentially merges <CR> <LF> sequences
-+	 *  into a single line terminator.  This must be handled by the caller.
-+	 */
-+
-+	if (cp == 0x000aL || cp == 0x000dL || cp == 0x2028L ||
-+	    cp == 0x2029L) {
-+		return 1;
-+	}
-+
-+	return 0;
-+}
-+
-+/*
-+ *  "IdentifierStart" production check.
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_start(duk_codepoint_t cp) {
-+	/*
-+	 *  E5 Section 7.6:
-+	 *
-+	 *    IdentifierStart:
-+	 *      UnicodeLetter
-+	 *      $
-+	 *      _
-+	 *      \ UnicodeEscapeSequence
-+	 *
-+	 *  IdentifierStart production has one multi-character production:
-+	 *
-+	 *    \ UnicodeEscapeSequence
-+	 *
-+	 *  The '\' character is -not- matched by this function.  Rather, the caller
-+	 *  should decode the escape and then call this function to check whether the
-+	 *  decoded character is acceptable (see discussion in E5 Section 7.6).
-+	 *
-+	 *  The "UnicodeLetter" alternative of the production allows letters
-+	 *  from various Unicode categories.  These can be extracted with the
-+	 *  "src/extract_chars.py" script.
-+	 *
-+	 *  Because the result has hundreds of Unicode codepoint ranges, matching
-+	 *  for any values >= 0x80 are done using a very slow range-by-range scan
-+	 *  and a packed range format.
-+	 *
-+	 *  The ASCII portion (codepoints 0x00 ... 0x7f) is fast-pathed below because
-+	 *  it matters the most.  The ASCII related ranges of IdentifierStart are:
-+	 *
-+	 *    0x0041 ... 0x005a     ['A' ... 'Z']
-+	 *    0x0061 ... 0x007a     ['a' ... 'z']
-+	 *    0x0024                ['$']
-+	 *    0x005f                ['_']
-+	 */
-+
-+	/* ASCII (and EOF) fast path -- quick accept and reject */
-+	if (cp <= 0x7fL) {
-+		if ((cp >= 'a' && cp <= 'z') ||
-+		    (cp >= 'A' && cp <= 'Z') ||
-+		    cp == '_' || cp == '$') {
-+			return 1;
-+		}
-+		return 0;
-+	}
-+
-+	/* Non-ASCII slow path (range-by-range linear comparison), very slow */
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+	if (duk__uni_range_match(duk_unicode_ids_noa,
-+	                         (duk_size_t) sizeof(duk_unicode_ids_noa),
-+	                         (duk_codepoint_t) cp)) {
-+		return 1;
-+	}
-+	return 0;
-+#else
-+	if (cp < 0x10000L) {
-+		if (duk__uni_range_match(duk_unicode_ids_noabmp,
-+		                         sizeof(duk_unicode_ids_noabmp),
-+		                         (duk_codepoint_t) cp)) {
-+			return 1;
-+		}
-+		return 0;
-+	} else {
-+		/* without explicit non-BMP support, assume non-BMP characters
-+		 * are always accepted as identifier characters.
-+		 */
-+		return 1;
-+	}
-+#endif
-+}
-+
-+/*
-+ *  "IdentifierPart" production check.
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_unicode_is_identifier_part(duk_codepoint_t cp) {
-+	/*
-+	 *  E5 Section 7.6:
-+	 *
-+	 *    IdentifierPart:
-+	 *      IdentifierStart
-+	 *      UnicodeCombiningMark
-+	 *      UnicodeDigit
-+	 *      UnicodeConnectorPunctuation
-+	 *      <ZWNJ>  [U+200C]
-+	 *      <ZWJ>   [U+200D]
-+	 *
-+	 *  IdentifierPart production has one multi-character production
-+	 *  as part of its IdentifierStart alternative.  The '\' character
-+	 *  of an escape sequence is not matched here, see discussion in
-+	 *  duk_unicode_is_identifier_start().
-+	 *
-+	 *  To match non-ASCII characters (codepoints >= 0x80), a very slow
-+	 *  linear range-by-range scan is used.  The codepoint is first compared
-+	 *  to the IdentifierStart ranges, and if it doesn't match, then to a
-+	 *  set consisting of code points in IdentifierPart but not in
-+	 *  IdentifierStart.  This is done to keep the unicode range data small,
-+	 *  at the expense of speed.
-+	 *
-+	 *  The ASCII fast path consists of:
-+	 *
-+	 *    0x0030 ... 0x0039     ['0' ... '9', UnicodeDigit]
-+	 *    0x0041 ... 0x005a     ['A' ... 'Z', IdentifierStart]
-+	 *    0x0061 ... 0x007a     ['a' ... 'z', IdentifierStart]
-+	 *    0x0024                ['$', IdentifierStart]
-+	 *    0x005f                ['_', IdentifierStart and
-+	 *                                UnicodeConnectorPunctuation]
-+	 *
-+	 *  UnicodeCombiningMark has no code points <= 0x7f.
-+	 *
-+	 *  The matching code reuses the "identifier start" tables, and then
-+	 *  consults a separate range set for characters in "identifier part"
-+	 *  but not in "identifier start".  These can be extracted with the
-+	 *  "src/extract_chars.py" script.
-+	 *
-+	 *  UnicodeCombiningMark -> categories Mn, Mc
-+	 *  UnicodeDigit -> categories Nd
-+	 *  UnicodeConnectorPunctuation -> categories Pc
-+	 */
-+
-+	/* ASCII (and EOF) fast path -- quick accept and reject */
-+	if (cp <= 0x7fL) {
-+		if ((cp >= 'a' && cp <= 'z') ||
-+		    (cp >= 'A' && cp <= 'Z') ||
-+		    (cp >= '0' && cp <= '9') ||
-+		    cp == '_' || cp == '$') {
-+			return 1;
-+		}
-+		return 0;
-+	}
-+
-+	/* Non-ASCII slow path (range-by-range linear comparison), very slow */
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+	if (duk__uni_range_match(duk_unicode_ids_noa,
-+	                         sizeof(duk_unicode_ids_noa),
-+	                         (duk_codepoint_t) cp) ||
-+	    duk__uni_range_match(duk_unicode_idp_m_ids_noa,
-+	                         sizeof(duk_unicode_idp_m_ids_noa),
-+	                         (duk_codepoint_t) cp)) {
-+		return 1;
-+	}
-+	return 0;
-+#else
-+	if (cp < 0x10000L) {
-+		if (duk__uni_range_match(duk_unicode_ids_noabmp,
-+		                         sizeof(duk_unicode_ids_noabmp),
-+		                         (duk_codepoint_t) cp) ||
-+		    duk__uni_range_match(duk_unicode_idp_m_ids_noabmp,
-+		                         sizeof(duk_unicode_idp_m_ids_noabmp),
-+		                         (duk_codepoint_t) cp)) {
-+			return 1;
-+		}
-+		return 0;
-+	} else {
-+		/* without explicit non-BMP support, assume non-BMP characters
-+		 * are always accepted as identifier characters.
-+		 */
-+		return 1;
-+	}
-+#endif
-+}
-+
-+/*
-+ *  Unicode letter check.
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_unicode_is_letter(duk_codepoint_t cp) {
-+	/*
-+	 *  Unicode letter is now taken to be the categories:
-+	 *
-+	 *    Lu, Ll, Lt, Lm, Lo
-+	 *
-+	 *  (Not sure if this is exactly correct.)
-+	 *
-+	 *  The ASCII fast path consists of:
-+	 *
-+	 *    0x0041 ... 0x005a     ['A' ... 'Z']
-+	 *    0x0061 ... 0x007a     ['a' ... 'z']
-+	 */
-+
-+	/* ASCII (and EOF) fast path -- quick accept and reject */
-+	if (cp <= 0x7fL) {
-+		if ((cp >= 'a' && cp <= 'z') ||
-+		    (cp >= 'A' && cp <= 'Z')) {
-+			return 1;
-+		}
-+		return 0;
-+	}
-+
-+	/* Non-ASCII slow path (range-by-range linear comparison), very slow */
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+	if (duk__uni_range_match(duk_unicode_ids_noa,
-+	                         sizeof(duk_unicode_ids_noa),
-+	                         (duk_codepoint_t) cp) &&
-+	    !duk__uni_range_match(duk_unicode_ids_m_let_noa,
-+	                          sizeof(duk_unicode_ids_m_let_noa),
-+	                          (duk_codepoint_t) cp)) {
-+		return 1;
-+	}
-+	return 0;
-+#else
-+	if (cp < 0x10000L) {
-+		if (duk__uni_range_match(duk_unicode_ids_noabmp,
-+		                         sizeof(duk_unicode_ids_noabmp),
-+		                         (duk_codepoint_t) cp) &&
-+		    !duk__uni_range_match(duk_unicode_ids_m_let_noabmp,
-+		                          sizeof(duk_unicode_ids_m_let_noabmp),
-+		                          (duk_codepoint_t) cp)) {
-+			return 1;
-+		}
-+		return 0;
-+	} else {
-+		/* without explicit non-BMP support, assume non-BMP characters
-+		 * are always accepted as letters.
-+		 */
-+		return 1;
-+	}
-+#endif
-+}
-+
-+/*
-+ *  Complex case conversion helper which decodes a bit-packed conversion
-+ *  control stream generated by unicode/extract_caseconv.py.  The conversion
-+ *  is very slow because it runs through the conversion data in a linear
-+ *  fashion to save space (which is why ASCII characters have a special
-+ *  fast path before arriving here).
-+ *
-+ *  The particular bit counts etc have been determined experimentally to
-+ *  be small but still sufficient, and must match the Python script
-+ *  (src/extract_caseconv.py).
-+ *
-+ *  The return value is the case converted codepoint or -1 if the conversion
-+ *  results in multiple characters (this is useful for regexp Canonicalization
-+ *  operation).  If 'buf' is not NULL, the result codepoint(s) are also
-+ *  appended to the hbuffer.
-+ *
-+ *  Context and locale specific rules must be checked before consulting
-+ *  this function.
-+ */
-+
-+DUK_LOCAL
-+duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr,
-+                                          duk_hbuffer_dynamic *buf,
-+                                          duk_codepoint_t cp,
-+                                          duk_bitdecoder_ctx *bd_ctx) {
-+	duk_small_int_t skip = 0;
-+	duk_small_int_t n;
-+	duk_small_int_t t;
-+	duk_small_int_t count;
-+	duk_codepoint_t tmp_cp;
-+	duk_codepoint_t start_i;
-+	duk_codepoint_t start_o;
-+
-+	DUK_DDD(DUK_DDDPRINT("slow case conversion for codepoint: %ld", (long) cp));
-+
-+	/* range conversion with a "skip" */
-+	DUK_DDD(DUK_DDDPRINT("checking ranges"));
-+	for (;;) {
-+		skip++;
-+		n = (duk_small_int_t) duk_bd_decode(bd_ctx, 6);
-+		if (n == 0x3f) {
-+			/* end marker */
-+			break;
-+		}
-+		DUK_DDD(DUK_DDDPRINT("skip=%ld, n=%ld", (long) skip, (long) n));
-+
-+		while (n--) {
-+			start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
-+			start_o = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
-+			count = (duk_small_int_t) duk_bd_decode(bd_ctx, 7);
-+			DUK_DDD(DUK_DDDPRINT("range: start_i=%ld, start_o=%ld, count=%ld, skip=%ld",
-+			                     (long) start_i, (long) start_o, (long) count, (long) skip));
-+
-+			if (cp >= start_i) {
-+				tmp_cp = cp - start_i;  /* always >= 0 */
-+				if (tmp_cp < (duk_codepoint_t) count * (duk_codepoint_t) skip &&
-+				    (tmp_cp % (duk_codepoint_t) skip) == 0) {
-+					DUK_DDD(DUK_DDDPRINT("range matches input codepoint"));
-+					cp = start_o + tmp_cp;
-+					goto single;
-+				}
-+			}
-+		}
-+	}
-+
-+	/* 1:1 conversion */
-+	n = (duk_small_int_t) duk_bd_decode(bd_ctx, 6);
-+	DUK_DDD(DUK_DDDPRINT("checking 1:1 conversions (count %ld)", (long) n));
-+	while (n--) {
-+		start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
-+		start_o = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
-+		DUK_DDD(DUK_DDDPRINT("1:1 conversion %ld -> %ld", (long) start_i, (long) start_o));
-+		if (cp == start_i) {
-+			DUK_DDD(DUK_DDDPRINT("1:1 matches input codepoint"));
-+			cp = start_o;
-+			goto single;
-+		}
-+	}
-+
-+	/* complex, multicharacter conversion */
-+	n = (duk_small_int_t) duk_bd_decode(bd_ctx, 7);
-+	DUK_DDD(DUK_DDDPRINT("checking 1:n conversions (count %ld)", (long) n));
-+	while (n--) {
-+		start_i = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
-+		t = (duk_small_int_t) duk_bd_decode(bd_ctx, 2);
-+		DUK_DDD(DUK_DDDPRINT("1:n conversion %ld -> %ld chars", (long) start_i, (long) t));
-+		if (cp == start_i) {
-+			DUK_DDD(DUK_DDDPRINT("1:n matches input codepoint"));
-+			if (buf) {
-+				while (t--) {
-+					tmp_cp = (duk_codepoint_t) duk_bd_decode(bd_ctx, 16);
-+					DUK_ASSERT(buf != NULL);
-+					duk_hbuffer_append_xutf8(thr, buf, (duk_ucodepoint_t) tmp_cp);
-+				}
-+			}
-+			return -1;
-+		} else {
-+			while (t--) {
-+				(void) duk_bd_decode(bd_ctx, 16);
-+			}
-+		}
-+	}
-+
-+	/* default: no change */
-+	DUK_DDD(DUK_DDDPRINT("no rule matches, output is same as input"));
-+	/* fall through */
-+
-+ single:
-+	if (buf) {
-+		duk_hbuffer_append_xutf8(thr, buf, cp);
-+	}
-+	return cp;
-+}
-+
-+/*
-+ *  Case conversion helper, with context/local sensitivity.
-+ *  For proper case conversion, one needs to know the character
-+ *  and the preceding and following characters, as well as
-+ *  locale/language.
-+ */
-+
-+/* XXX: add 'language' argument when locale/language sensitive rule
-+ * support added.
-+ */
-+DUK_LOCAL
-+duk_codepoint_t duk__case_transform_helper(duk_hthread *thr,
-+                                           duk_hbuffer_dynamic *buf,
-+                                           duk_codepoint_t cp,
-+                                           duk_codepoint_t prev,
-+                                           duk_codepoint_t next,
-+                                           duk_bool_t uppercase) {
-+	duk_bitdecoder_ctx bd_ctx;
-+
-+	/* fast path for ASCII */
-+	if (cp < 0x80L) {
-+		/* XXX: there are language sensitive rules for the ASCII range.
-+		 * If/when language/locale support is implemented, they need to
-+		 * be implemented here for the fast path.  There are no context
-+		 * sensitive rules for ASCII range.
-+		 */
-+
-+		if (uppercase) {
-+			if (cp >= 'a' && cp <= 'z') {
-+				cp = cp - 'a' + 'A';
-+			}
-+		} else {
-+			if (cp >= 'A' && cp <= 'Z') {
-+				cp = cp - 'A' + 'a';
-+			}
-+		}
-+		goto singlechar;
-+	}
-+
-+	/* context and locale specific rules which cannot currently be represented
-+	 * in the caseconv bitstream: hardcoded rules in C
-+	 */
-+	if (uppercase) {
-+		/* XXX: turkish / azeri */
-+	} else {
-+		/*
-+		 *  Final sigma context specific rule.  This is a rather tricky
-+		 *  rule and this handling is probably not 100% correct now.
-+		 *  The rule is not locale/language specific so it is supported.
-+		 */
-+
-+		if (cp == 0x03a3L &&    /* U+03A3 = GREEK CAPITAL LETTER SIGMA */
-+		    duk_unicode_is_letter(prev) &&        /* prev exists and is not a letter */
-+		    !duk_unicode_is_letter(next)) {       /* next does not exist or next is not a letter */
-+			/* Capital sigma occurred at "end of word", lowercase to
-+			 * U+03C2 = GREEK SMALL LETTER FINAL SIGMA.  Otherwise
-+			 * fall through and let the normal rules lowercase it to
-+			 * U+03C3 = GREEK SMALL LETTER SIGMA.
-+			 */
-+			cp = 0x03c2L;
-+			goto singlechar;
-+		}
-+
-+		/* XXX: lithuanian not implemented */
-+		/* XXX: lithuanian, explicit dot rules */
-+		/* XXX: turkish / azeri, lowercase rules */
-+	}
-+
-+	/* 1:1 or special conversions, but not locale/context specific: script generated rules */
-+	DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
-+	if (uppercase) {
-+		bd_ctx.data = (duk_uint8_t *) duk_unicode_caseconv_uc;
-+		bd_ctx.length = (duk_size_t) sizeof(duk_unicode_caseconv_uc);
-+	} else {
-+		bd_ctx.data = (duk_uint8_t *) duk_unicode_caseconv_lc;
-+		bd_ctx.length = (duk_size_t) sizeof(duk_unicode_caseconv_lc);
-+	}
-+	return duk__slow_case_conversion(thr, buf, cp, &bd_ctx);
-+
-+ singlechar:
-+	if (buf) {
-+		duk_hbuffer_append_xutf8(thr, buf, cp);
-+	}
-+	return cp;
-+
-+ /* unused now, not needed until Turkish/Azeri */
-+#if 0
-+ nochar:
-+	return -1;
-+#endif
-+}
-+
-+/*
-+ *  Replace valstack top with case converted version.
-+ */
-+
-+DUK_INTERNAL void duk_unicode_case_convert_string(duk_hthread *thr, duk_small_int_t uppercase) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *h_input;
-+	duk_hbuffer_dynamic *h_buf;
-+	const duk_uint8_t *p, *p_start, *p_end;
-+	duk_codepoint_t prev, curr, next;
-+
-+	h_input = duk_require_hstring(ctx, -1);
-+	DUK_ASSERT(h_input != NULL);
-+
-+	/* XXX: should init the buffer with a spare of at least h_input->blen
-+	 * to avoid unnecessary growth steps.
-+	 */
-+	duk_push_dynamic_buffer(ctx, 0);
-+	h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(h_buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf));
-+
-+	/* [ ... input buffer ] */
-+
-+	p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
-+	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
-+	p = p_start;
-+
-+	prev = -1; DUK_UNREF(prev);
-+	curr = -1;
-+	next = -1;
-+	for (;;) {
-+		prev = curr;
-+		curr = next;
-+		next = -1;
-+		if (p < p_end) {
-+			next = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
-+		} else {
-+			/* end of input and last char has been processed */
-+			if (curr < 0) {
-+				break;
-+			}
-+		}
-+
-+		/* on first round, skip */
-+		if (curr >= 0) {
-+			/* may generate any number of output codepoints */
-+			duk__case_transform_helper(thr,
-+			                           h_buf,
-+			                           (duk_codepoint_t) curr,
-+			                           prev,
-+			                           next,
-+			                           uppercase);
-+		}
-+	}
-+
-+	duk_to_string(ctx, -1);  /* invalidates h_buf pointer */
-+	duk_remove(ctx, -2);
-+}
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+
-+/*
-+ *  Canonicalize() abstract operation needed for canonicalization of individual
-+ *  codepoints during regexp compilation and execution, see E5 Section 15.10.2.8.
-+ *  Note that codepoints are canonicalized one character at a time, so no context
-+ *  specific rules can apply.  Locale specific rules can apply, though.
-+ */
-+
-+DUK_INTERNAL duk_codepoint_t duk_unicode_re_canonicalize_char(duk_hthread *thr, duk_codepoint_t cp) {
-+	duk_codepoint_t y;
-+
-+	y = duk__case_transform_helper(thr,
-+	                               NULL,    /* buf */
-+	                               cp,      /* curr char */
-+	                               -1,      /* prev char */
-+	                               -1,      /* next char */
-+	                               1);      /* uppercase */
-+
-+	if ((y < 0) || (cp >= 0x80 && y < 0x80)) {
-+		/* multiple codepoint conversion or non-ASCII mapped to ASCII
-+		 * --> leave as is.
-+		 */
-+		return cp;
-+	}
-+
-+	return y;
-+}
-+
-+/*
-+ *  E5 Section 15.10.2.6 "IsWordChar" abstract operation.  Assume
-+ *  x < 0 for characters read outside the string.
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_unicode_re_is_wordchar(duk_codepoint_t x) {
-+	/*
-+	 *  Note: the description in E5 Section 15.10.2.6 has a typo, it
-+	 *  contains 'A' twice and lacks 'a'; the intent is [0-9a-zA-Z_].
-+	 */
-+	if ((x >= '0' && x <= '9') ||
-+	    (x >= 'a' && x <= 'z') ||
-+	    (x >= 'A' && x <= 'Z') ||
-+	    (x == '_')) {
-+		return 1;
-+	}
-+	return 0;
-+}
-+
-+/*
-+ *  Regexp range tables
-+ */
-+
-+/* exposed because lexer needs these too */
-+DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_digit[2] = {
-+	(duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
-+};
-+DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_white[22] = {
-+	(duk_uint16_t) 0x0009UL, (duk_uint16_t) 0x000DUL,
-+	(duk_uint16_t) 0x0020UL, (duk_uint16_t) 0x0020UL,
-+	(duk_uint16_t) 0x00A0UL, (duk_uint16_t) 0x00A0UL,
-+	(duk_uint16_t) 0x1680UL, (duk_uint16_t) 0x1680UL,
-+	(duk_uint16_t) 0x180EUL, (duk_uint16_t) 0x180EUL,
-+	(duk_uint16_t) 0x2000UL, (duk_uint16_t) 0x200AUL,
-+	(duk_uint16_t) 0x2028UL, (duk_uint16_t) 0x2029UL,
-+	(duk_uint16_t) 0x202FUL, (duk_uint16_t) 0x202FUL,
-+	(duk_uint16_t) 0x205FUL, (duk_uint16_t) 0x205FUL,
-+	(duk_uint16_t) 0x3000UL, (duk_uint16_t) 0x3000UL,
-+	(duk_uint16_t) 0xFEFFUL, (duk_uint16_t) 0xFEFFUL,
-+};
-+DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_wordchar[8] = {
-+	(duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
-+	(duk_uint16_t) 0x0041UL, (duk_uint16_t) 0x005AUL,
-+	(duk_uint16_t) 0x005FUL, (duk_uint16_t) 0x005FUL,
-+	(duk_uint16_t) 0x0061UL, (duk_uint16_t) 0x007AUL,
-+};
-+DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_not_digit[4] = {
-+	(duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x002FUL,
-+	(duk_uint16_t) 0x003AUL, (duk_uint16_t) 0xFFFFUL,
-+};
-+DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_not_white[24] = {
-+	(duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x0008UL,
-+	(duk_uint16_t) 0x000EUL, (duk_uint16_t) 0x001FUL,
-+	(duk_uint16_t) 0x0021UL, (duk_uint16_t) 0x009FUL,
-+	(duk_uint16_t) 0x00A1UL, (duk_uint16_t) 0x167FUL,
-+	(duk_uint16_t) 0x1681UL, (duk_uint16_t) 0x180DUL,
-+	(duk_uint16_t) 0x180FUL, (duk_uint16_t) 0x1FFFUL,
-+	(duk_uint16_t) 0x200BUL, (duk_uint16_t) 0x2027UL,
-+	(duk_uint16_t) 0x202AUL, (duk_uint16_t) 0x202EUL,
-+	(duk_uint16_t) 0x2030UL, (duk_uint16_t) 0x205EUL,
-+	(duk_uint16_t) 0x2060UL, (duk_uint16_t) 0x2FFFUL,
-+	(duk_uint16_t) 0x3001UL, (duk_uint16_t) 0xFEFEUL,
-+	(duk_uint16_t) 0xFF00UL, (duk_uint16_t) 0xFFFFUL,
-+};
-+DUK_INTERNAL duk_uint16_t duk_unicode_re_ranges_not_wordchar[10] = {
-+	(duk_uint16_t) 0x0000UL, (duk_uint16_t) 0x002FUL,
-+	(duk_uint16_t) 0x003AUL, (duk_uint16_t) 0x0040UL,
-+	(duk_uint16_t) 0x005BUL, (duk_uint16_t) 0x005EUL,
-+	(duk_uint16_t) 0x0060UL, (duk_uint16_t) 0x0060UL,
-+	(duk_uint16_t) 0x007BUL, (duk_uint16_t) 0xFFFFUL,
-+};
-+
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+#line 1 "duk_util_misc.c"
-+/*
-+ *  Misc util stuff
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Lowercase digits for radix values 2 to 36.  Also doubles as lowercase
-+ *  hex nybble table.
-+ */
-+
-+DUK_INTERNAL duk_uint8_t duk_lc_digits[36] = {
-+	'0', '1', '2', '3', '4', '5', '6', '7',
-+	'8', '9', 'a', 'b', 'c', 'd', 'e', 'f',
-+	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
-+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
-+	'w', 'x', 'y', 'z'
-+};
-+
-+DUK_INTERNAL duk_uint8_t duk_uc_nybbles[16] = {
-+	'0', '1', '2', '3', '4', '5', '6', '7',
-+	'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
-+};
-+
-+/*
-+ *  Table for decoding ASCII hex digits, -1 if invalid.
-+ */
-+
-+DUK_INTERNAL duk_int8_t duk_hex_dectab[256] = {
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x00-0x0f */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x10-0x1f */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x20-0x2f */
-+	 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,  /* 0x30-0x3f */
-+	-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x40-0x4f */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x50-0x5f */
-+	-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x60-0x6f */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x70-0x7f */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x80-0x8f */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0x90-0x9f */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0xa0-0xaf */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0xb0-0xbf */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0xc0-0xcf */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0xd0-0xdf */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  /* 0xe0-0xef */
-+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1   /* 0xf0-0xff */
-+};
-+
-+/*
-+ *  Arbitrary byteswap for potentially unaligned values
-+ *
-+ *  Used to byteswap pointers e.g. in debugger code.
-+ */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)  /* For now only needed by the debugger. */
-+DUK_INTERNAL void duk_byteswap_bytes(duk_uint8_t *p, duk_small_uint_t len) {
-+	duk_uint8_t tmp;
-+	duk_uint8_t *q = p + len - 1;
-+
-+	while (p - q < 0) {
-+		tmp = *p;
-+		*p = *q;
-+		*q = tmp;
-+		p++;
-+		q--;
-+	}
-+}
-+#endif
-+#line 1 "duk_util_hashprime.c"
-+/*
-+ *  Round a number upwards to a prime (not usually the nearest one).
-+ *
-+ *  Uses a table of successive 32-bit primes whose ratio is roughly
-+ *  constant.  This keeps the relative upwards 'rounding error' bounded
-+ *  and the data size small.  A simple 'predict-correct' compression is
-+ *  used to compress primes to one byte per prime.  See genhashsizes.py
-+ *  for details.
-+ *
-+ *  The minimum prime returned here must be coordinated with the possible
-+ *  probe sequence steps in duk_hobject and duk_heap stringtable.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* Awkward inclusion condition: drop out of compilation if not needed by any
-+ * call site: object hash part or probing stringtable.
-+ */
-+#if defined(DUK_USE_HOBJECT_HASH_PART) || defined(DUK_USE_STRTAB_PROBE)
-+
-+/* hash size ratio goal, must match genhashsizes.py */
-+#define DUK__HASH_SIZE_RATIO   1177  /* floor(1.15 * (1 << 10)) */
-+
-+/* prediction corrections for prime list (see genhashsizes.py) */
-+DUK_LOCAL const duk_int8_t duk__hash_size_corrections[] = {
-+	17,  /* minimum prime */
-+	4, 3, 4, 1, 4, 1, 1, 2, 2, 2, 2, 1, 6, 6, 9, 5, 1, 2, 2, 5, 1, 3, 3, 3,
-+	5, 4, 4, 2, 4, 8, 3, 4, 23, 2, 4, 7, 8, 11, 2, 12, 15, 10, 1, 1, 5, 1, 5,
-+	8, 9, 17, 14, 10, 7, 5, 2, 46, 21, 1, 9, 9, 4, 4, 10, 23, 36, 6, 20, 29,
-+	18, 6, 19, 21, 16, 11, 5, 5, 48, 9, 1, 39, 14, 8, 4, 29, 9, 1, 15, 48, 12,
-+	22, 6, 15, 27, 4, 2, 17, 28, 8, 9, 4, 5, 8, 3, 3, 8, 37, 11, 15, 8, 30,
-+	43, 6, 33, 41, 5, 20, 32, 41, 38, 24, 77, 14, 19, 11, 4, 35, 18, 19, 41,
-+	10, 23, 16, 9, 2,
-+	-1
-+};
-+
-+/* probe steps (see genhashsizes.py), currently assumed to be 32 entries long
-+ * (DUK_UTIL_GET_HASH_PROBE_STEP macro).
-+ */
-+DUK_INTERNAL duk_uint8_t duk_util_probe_steps[32] = {
-+	2, 3, 5, 7, 11, 13, 19, 31, 41, 47, 59, 67, 73, 79, 89, 101, 103, 107,
-+	109, 127, 137, 139, 149, 157, 163, 167, 173, 181, 191, 193, 197, 199
-+};
-+
-+DUK_INTERNAL duk_uint32_t duk_util_get_hash_prime(duk_uint32_t size) {
-+	const duk_int8_t *p = duk__hash_size_corrections;
-+	duk_uint32_t curr;
-+
-+	curr = (duk_uint32_t) *p++;
-+	for (;;) {
-+		duk_small_int_t t = (duk_small_int_t) *p++;
-+		if (t < 0) {
-+			/* may happen if size is very close to 2^32-1 */
-+			break;
-+		}
-+
-+		/* prediction: portable variant using doubles if 64-bit values not available */
-+#ifdef DUK_USE_64BIT_OPS
-+		curr = (duk_uint32_t) ((((duk_uint64_t) curr) * ((duk_uint64_t) DUK__HASH_SIZE_RATIO)) >> 10);
-+#else
-+		/* 32-bit x 11-bit = 43-bit, fits accurately into a double */
-+		curr = (duk_uint32_t) DUK_FLOOR(((double) curr) * ((double) DUK__HASH_SIZE_RATIO) / 1024.0);
-+#endif
-+
-+		/* correction */
-+		curr += t;
-+
-+		DUK_DDD(DUK_DDDPRINT("size=%ld, curr=%ld", (long) size, (long) curr));
-+
-+		if (curr >= size) {
-+			return curr;
-+		}
-+	}
-+	return 0;
-+}
-+
-+#endif  /* DUK_USE_HOBJECT_HASH_PART || DUK_USE_STRTAB_PROBE */
-+#line 1 "duk_hobject_class.c"
-+/*
-+ *  Hobject Ecmascript [[Class]].
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* Maybe better to check these elsewhere */
-+#if (DUK_STRIDX_UC_ARGUMENTS > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_ARRAY > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_UC_BOOLEAN > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_DATE > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_UC_ERROR > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_UC_FUNCTION > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_JSON > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_MATH > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_UC_NUMBER > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_UC_OBJECT > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_REG_EXP > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_UC_STRING > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_GLOBAL > 255)
-+#error constant too large
-+#endif
-+#if (DUK_STRIDX_EMPTY_STRING > 255)
-+#error constant too large
-+#endif
-+
-+/* Note: assumes that these string indexes are 8-bit, genstrings.py must ensure that */
-+DUK_INTERNAL duk_uint8_t duk_class_number_to_stridx[32] = {
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_UC_ARGUMENTS,
-+	DUK_STRIDX_ARRAY,
-+	DUK_STRIDX_UC_BOOLEAN,
-+	DUK_STRIDX_DATE,
-+	DUK_STRIDX_UC_ERROR,
-+	DUK_STRIDX_UC_FUNCTION,
-+	DUK_STRIDX_JSON,
-+	DUK_STRIDX_MATH,
-+	DUK_STRIDX_UC_NUMBER,
-+	DUK_STRIDX_UC_OBJECT,
-+	DUK_STRIDX_REG_EXP,
-+	DUK_STRIDX_UC_STRING,
-+	DUK_STRIDX_GLOBAL,
-+	DUK_STRIDX_OBJ_ENV,
-+	DUK_STRIDX_DEC_ENV,
-+	DUK_STRIDX_UC_BUFFER,
-+	DUK_STRIDX_UC_POINTER,
-+	DUK_STRIDX_UC_THREAD,     /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+	DUK_STRIDX_EMPTY_STRING,  /* UNUSED, intentionally empty */
-+};
-+#line 1 "duk_alloc_default.c"
-+/*
-+ *  Default allocation functions.
-+ *
-+ *  Assumes behavior such as malloc allowing zero size, yielding
-+ *  a NULL or a unique pointer which is a no-op for free.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL void *duk_default_alloc_function(void *udata, duk_size_t size) {
-+	void *res;
-+	DUK_UNREF(udata);
-+	res = DUK_ANSI_MALLOC(size);
-+	DUK_DDD(DUK_DDDPRINT("default alloc function: %lu -> %p",
-+	                     (unsigned long) size, (void *) res));
-+	return res;
-+}
-+
-+DUK_INTERNAL void *duk_default_realloc_function(void *udata, void *ptr, duk_size_t newsize) {
-+	void *res;
-+	DUK_UNREF(udata);
-+	res = DUK_ANSI_REALLOC(ptr, newsize);
-+	DUK_DDD(DUK_DDDPRINT("default realloc function: %p %lu -> %p",
-+	                     (void *) ptr, (unsigned long) newsize, (void *) res));
-+	return res;
-+}
-+
-+DUK_INTERNAL void duk_default_free_function(void *udata, void *ptr) {
-+	DUK_DDD(DUK_DDDPRINT("default free function: %p", (void *) ptr));
-+	DUK_UNREF(udata);
-+	DUK_ANSI_FREE(ptr);
-+}
-+#line 1 "duk_api_buffer.c"
-+/*
-+ *  Buffer
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_EXTERNAL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hbuffer_dynamic *h;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	h = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, index);
-+	DUK_ASSERT(h != NULL);
-+
-+	if (!DUK_HBUFFER_HAS_DYNAMIC(h)) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_BUFFER_NOT_DYNAMIC);
-+	}
-+
-+	/* maximum size check is handled by callee */
-+	duk_hbuffer_resize(thr, h, new_size, new_size);  /* snug */
-+
-+	return DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h);
-+}
-+#line 1 "duk_api_call.c"
-+/*
-+ *  Calls.
-+ *
-+ *  Protected variants should avoid ever throwing an error.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* Prepare value stack for a method call through an object property.
-+ * May currently throw an error e.g. when getting the property.
-+ */
-+DUK_LOCAL void duk__call_prop_prep_stack(duk_context *ctx, duk_idx_t normalized_obj_index, duk_idx_t nargs) {
-+	DUK_DDD(DUK_DDDPRINT("duk__call_prop_prep_stack, normalized_obj_index=%ld, nargs=%ld, stacktop=%ld",
-+	                     (long) normalized_obj_index, (long) nargs, (long) duk_get_top(ctx)));
-+
-+	/* [... key arg1 ... argN] */
-+
-+	/* duplicate key */
-+	duk_dup(ctx, -nargs - 1);  /* Note: -nargs alone would fail for nargs == 0, this is OK */
-+	duk_get_prop(ctx, normalized_obj_index);
-+
-+	DUK_DDD(DUK_DDDPRINT("func: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/* [... key arg1 ... argN func] */
-+
-+	duk_replace(ctx, -nargs - 2);
-+
-+	/* [... func arg1 ... argN] */
-+
-+	duk_dup(ctx, normalized_obj_index);
-+	duk_insert(ctx, -nargs - 1);
-+
-+	/* [... func this arg1 ... argN] */
-+}
-+
-+DUK_EXTERNAL void duk_call(duk_context *ctx, duk_idx_t nargs) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_small_uint_t call_flags;
-+	duk_idx_t idx_func;
-+	duk_int_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+
-+	idx_func = duk_get_top(ctx) - nargs - 1;
-+	if (idx_func < 0 || nargs < 0) {
-+		/* note that we can't reliably pop anything here */
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+	}
-+
-+	/* XXX: awkward; we assume there is space for this, overwrite
-+	 * directly instead?
-+	 */
-+	duk_push_undefined(ctx);
-+	duk_insert(ctx, idx_func + 1);
-+
-+	call_flags = 0;  /* not protected, respect reclimit, not constructor */
-+
-+	rc = duk_handle_call(thr,           /* thread */
-+	                     nargs,         /* num_stack_args */
-+	                     call_flags);   /* call_flags */
-+	DUK_UNREF(rc);
-+}
-+
-+DUK_EXTERNAL void duk_call_method(duk_context *ctx, duk_idx_t nargs) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_small_uint_t call_flags;
-+	duk_idx_t idx_func;
-+	duk_int_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+
-+	idx_func = duk_get_top(ctx) - nargs - 2;  /* must work for nargs <= 0 */
-+	if (idx_func < 0 || nargs < 0) {
-+		/* note that we can't reliably pop anything here */
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+	}
-+
-+	call_flags = 0;  /* not protected, respect reclimit, not constructor */
-+
-+	rc = duk_handle_call(thr,           /* thread */
-+	                     nargs,         /* num_stack_args */
-+	                     call_flags);   /* call_flags */
-+	DUK_UNREF(rc);
-+}
-+
-+DUK_EXTERNAL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs) {
-+	/*
-+	 *  XXX: if duk_handle_call() took values through indices, this could be
-+	 *  made much more sensible.  However, duk_handle_call() needs to fudge
-+	 *  the 'this' and 'func' values to handle bound function chains, which
-+	 *  is now done "in-place", so this is not a trivial change.
-+	 */
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);  /* make absolute */
-+
-+	duk__call_prop_prep_stack(ctx, obj_index, nargs);
-+
-+	duk_call_method(ctx, nargs);
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_small_uint_t call_flags;
-+	duk_idx_t idx_func;
-+	duk_int_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+
-+	idx_func = duk_get_top(ctx) - nargs - 1;  /* must work for nargs <= 0 */
-+	if (idx_func < 0 || nargs < 0) {
-+		/* We can't reliably pop anything here because the stack input
-+		 * shape is incorrect.  So we throw an error; if the caller has
-+		 * no catch point for this, a fatal error will occur.  Another
-+		 * alternative would be to just return an error.  But then the
-+		 * stack would be in an unknown state which might cause some
-+		 * very hard to diagnose problems later on.  Also note that even
-+		 * if we did not throw an error here, the underlying call handler
-+		 * might STILL throw an out-of-memory error or some other internal
-+		 * fatal error.
-+		 */
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+		return DUK_EXEC_ERROR;  /* unreachable */
-+	}
-+
-+	/* awkward; we assume there is space for this */
-+	duk_push_undefined(ctx);
-+	duk_insert(ctx, idx_func + 1);
-+
-+	call_flags = DUK_CALL_FLAG_PROTECTED;  /* protected, respect reclimit, not constructor */
-+
-+	rc = duk_handle_call(thr,           /* thread */
-+	                     nargs,         /* num_stack_args */
-+	                     call_flags);   /* call_flags */
-+
-+	return rc;
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_small_uint_t call_flags;
-+	duk_idx_t idx_func;
-+	duk_int_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+
-+	idx_func = duk_get_top(ctx) - nargs - 2;  /* must work for nargs <= 0 */
-+	if (idx_func < 0 || nargs < 0) {
-+		/* See comments in duk_pcall(). */
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+		return DUK_EXEC_ERROR;  /* unreachable */
-+	}
-+
-+	call_flags = DUK_CALL_FLAG_PROTECTED;  /* protected, respect reclimit, not constructor */
-+
-+	rc = duk_handle_call(thr,           /* thread */
-+	                     nargs,         /* num_stack_args */
-+	                     call_flags);   /* call_flags */
-+
-+	return rc;
-+}
-+
-+DUK_LOCAL duk_ret_t duk__pcall_prop_raw(duk_context *ctx) {
-+	duk_idx_t obj_index;
-+	duk_idx_t nargs;
-+
-+	/* Get the original arguments.  Note that obj_index may be a relative
-+	 * index so the stack must have the same top when we use it.
-+	 */
-+
-+	obj_index = (duk_idx_t) duk_get_int(ctx, -2);
-+	nargs = (duk_idx_t) duk_get_int(ctx, -1);
-+	duk_pop_2(ctx);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);  /* make absolute */
-+	duk__call_prop_prep_stack(ctx, obj_index, nargs);
-+	duk_call_method(ctx, nargs);
-+	return 1;
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs) {
-+	/*
-+	 *  Must be careful to catch errors related to value stack manipulation
-+	 *  and property lookup, not just the call itself.
-+	 */
-+
-+	duk_push_idx(ctx, obj_index);
-+	duk_push_idx(ctx, nargs);
-+
-+	/* Inputs: explicit arguments (nargs), +1 for key, +2 for obj_index/nargs passing.
-+	 * If the value stack does not contain enough args, an error is thrown; this matches
-+	 * behavior of the other protected call API functions.
-+	 */
-+	return duk_safe_call(ctx, duk__pcall_prop_raw, nargs + 1 + 2 /*nargs*/, 1 /*nrets*/);
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_int_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+
-+	if (duk_get_top(ctx) < nargs || nrets < 0) {
-+		/* See comments in duk_pcall(). */
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+		return DUK_EXEC_ERROR;  /* unreachable */
-+	}
-+
-+	rc = duk_handle_safe_call(thr,           /* thread */
-+	                          func,          /* func */
-+	                          nargs,         /* num_stack_args */
-+	                          nrets);        /* num_stack_res */
-+
-+	return rc;
-+}
-+
-+DUK_EXTERNAL void duk_new(duk_context *ctx, duk_idx_t nargs) {
-+	/*
-+	 *  There are two [[Construct]] operations in the specification:
-+	 *
-+	 *    - E5 Section 13.2.2: for Function objects
-+	 *    - E5 Section 15.3.4.5.2: for "bound" Function objects
-+	 *
-+	 *  The chain of bound functions is resolved in Section 15.3.4.5.2,
-+	 *  with arguments "piling up" until the [[Construct]] internal
-+	 *  method is called on the final, actual Function object.  Note
-+	 *  that the "prototype" property is looked up *only* from the
-+	 *  final object, *before* calling the constructor.
-+	 *
-+	 *  Currently we follow the bound function chain here to get the
-+	 *  "prototype" property value from the final, non-bound function.
-+	 *  However, we let duk_handle_call() handle the argument "piling"
-+	 *  when the constructor is called.  The bound function chain is
-+	 *  thus now processed twice.
-+	 *
-+	 *  When constructing new Array instances, an unnecessary object is
-+	 *  created and discarded now: the standard [[Construct]] creates an
-+	 *  object, and calls the Array constructor.  The Array constructor
-+	 *  returns an Array instance, which is used as the result value for
-+	 *  the "new" operation; the object created before the Array constructor
-+	 *  call is discarded.
-+	 *
-+	 *  This would be easy to fix, e.g. by knowing that the Array constructor
-+	 *  will always create a replacement object and skip creating the fallback
-+	 *  object in that case.
-+	 *
-+	 *  Note: functions called via "new" need to know they are called as a
-+	 *  constructor.  For instance, built-in constructors behave differently
-+	 *  depending on how they are called.
-+	 */
-+
-+	/* XXX: merge this with duk_js_call.c, as this function implements
-+	 * core semantics (or perhaps merge the two files altogether).
-+	 */
-+
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *proto;
-+	duk_hobject *cons;
-+	duk_hobject *fallback;
-+	duk_idx_t idx_cons;
-+	duk_small_uint_t call_flags;
-+	duk_int_t rc;
-+
-+	/* [... constructor arg1 ... argN] */
-+
-+	idx_cons = duk_require_normalize_index(ctx, -nargs - 1);
-+
-+	DUK_DDD(DUK_DDDPRINT("top=%ld, nargs=%ld, idx_cons=%ld",
-+	                     (long) duk_get_top(ctx), (long) nargs, (long) idx_cons));
-+
-+	/* XXX: code duplication */
-+
-+	/*
-+	 *  Figure out the final, non-bound constructor, to get "prototype"
-+	 *  property.
-+	 */
-+
-+	duk_dup(ctx, idx_cons);
-+	for (;;) {
-+		cons = duk_get_hobject(ctx, -1);
-+		if (cons == NULL || !DUK_HOBJECT_HAS_CONSTRUCTABLE(cons)) {
-+			/* Checking constructability from anything else than the
-+			 * initial constructor is not strictly necessary, but a
-+			 * nice sanity check.
-+			 */
-+			goto not_constructable;
-+		}
-+		if (!DUK_HOBJECT_HAS_BOUND(cons)) {
-+			break;
-+		}
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET);  /* -> [... cons target] */
-+		duk_remove(ctx, -2);                                  /* -> [... target] */
-+	}
-+	DUK_ASSERT(cons != NULL && !DUK_HOBJECT_HAS_BOUND(cons));
-+
-+	/* [... constructor arg1 ... argN final_cons] */
-+
-+	/*
-+	 *  Create "fallback" object to be used as the object instance,
-+	 *  unless the constructor returns a replacement value.
-+	 *  Its internal prototype needs to be set based on "prototype"
-+	 *  property of the constructor.
-+	 */
-+
-+	duk_push_object(ctx);  /* class Object, extensible */
-+
-+	/* [... constructor arg1 ... argN final_cons fallback] */
-+
-+	duk_get_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE);
-+	proto = duk_get_hobject(ctx, -1);
-+	if (!proto) {
-+		DUK_DDD(DUK_DDDPRINT("constructor has no 'prototype' property, or value not an object "
-+		                     "-> leave standard Object prototype as fallback prototype"));
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("constructor has 'prototype' property with object value "
-+		                     "-> set fallback prototype to that value: %!iO", (duk_heaphdr *) proto));
-+		fallback = duk_get_hobject(ctx, -2);
-+		DUK_ASSERT(fallback != NULL);
-+		DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, fallback, proto);
-+	}
-+	duk_pop(ctx);
-+
-+	/* [... constructor arg1 ... argN final_cons fallback] */
-+
-+	/*
-+	 *  Manipulate callstack for the call.
-+	 */
-+
-+	duk_dup_top(ctx);
-+	duk_insert(ctx, idx_cons + 1);  /* use fallback as 'this' value */
-+	duk_insert(ctx, idx_cons);      /* also stash it before constructor,
-+	                                 * in case we need it (as the fallback value)
-+	                                 */
-+	duk_pop(ctx);                   /* pop final_cons */
-+
-+
-+	/* [... fallback constructor fallback(this) arg1 ... argN];
-+	 * Note: idx_cons points to first 'fallback', not 'constructor'.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("before call, idx_cons+1 (constructor) -> %!T, idx_cons+2 (fallback/this) -> %!T, "
-+	                     "nargs=%ld, top=%ld",
-+	                     (duk_tval *) duk_get_tval(ctx, idx_cons + 1),
-+	                     (duk_tval *) duk_get_tval(ctx, idx_cons + 2),
-+	                     (long) nargs,
-+	                     (long) duk_get_top(ctx)));
-+
-+	/*
-+	 *  Call the constructor function (called in "constructor mode").
-+	 */
-+
-+	call_flags = DUK_CALL_FLAG_CONSTRUCTOR_CALL;  /* not protected, respect reclimit, is a constructor call */
-+
-+	rc = duk_handle_call(thr,           /* thread */
-+	                     nargs,         /* num_stack_args */
-+	                     call_flags);   /* call_flags */
-+	DUK_UNREF(rc);
-+
-+	/* [... fallback retval] */
-+
-+	DUK_DDD(DUK_DDDPRINT("constructor call finished, rc=%ld, fallback=%!iT, retval=%!iT",
-+	                     (long) rc,
-+	                     (duk_tval *) duk_get_tval(ctx, -2),
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/*
-+	 *  Determine whether to use the constructor return value as the created
-+	 *  object instance or not.
-+	 */
-+
-+	if (duk_is_object(ctx, -1)) {
-+		duk_remove(ctx, -2);
-+	} else {
-+		duk_pop(ctx);
-+	}
-+
-+	/*
-+	 *  Augment created errors upon creation (not when they are thrown or
-+	 *  rethrown).  __FILE__ and __LINE__ are not desirable here; the call
-+	 *  stack reflects the caller which is correct.
-+	 */
-+
-+#ifdef DUK_USE_AUGMENT_ERROR_CREATE
-+	duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/);
-+#endif
-+
-+	/* [... retval] */
-+
-+	return;
-+
-+ not_constructable:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONSTRUCTABLE);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_constructor_call(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_activation *act;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
-+
-+	act = duk_hthread_get_current_activation(thr);
-+	DUK_ASSERT(act != NULL);  /* because callstack_top > 0 */
-+	return ((act->flags & DUK_ACT_FLAG_CONSTRUCT) != 0 ? 1 : 0);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_strict_call(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_activation *act;
-+
-+	/* For user code this could just return 1 (strict) always
-+	 * because all Duktape/C functions are considered strict,
-+	 * and strict is also the default when nothing is running.
-+	 * However, Duktape may call this function internally when
-+	 * the current activation is an Ecmascript function, so
-+	 * this cannot be replaced by a 'return 1' without fixing
-+	 * the internal call sites.
-+	 */
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
-+
-+	act = duk_hthread_get_current_activation(thr);
-+	if (act == NULL) {
-+		/* Strict by default. */
-+		return 1;
-+	}
-+	return ((act->flags & DUK_ACT_FLAG_STRICT) != 0 ? 1 : 0);
-+}
-+
-+/*
-+ *  Duktape/C function magic
-+ */
-+
-+DUK_EXTERNAL duk_int_t duk_get_current_magic(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_activation *act;
-+	duk_hobject *func;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
-+
-+	act = duk_hthread_get_current_activation(thr);
-+	if (act) {
-+		func = DUK_ACT_GET_FUNC(act);
-+		if (!func) {
-+			duk_tval *tv = &act->tv_func;
-+			duk_small_uint_t lf_flags;
-+			lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
-+			return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
-+		}
-+		DUK_ASSERT(func != NULL);
-+
-+		if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
-+			duk_hnativefunction *nf = (duk_hnativefunction *) func;
-+			return (duk_int_t) nf->magic;
-+		}
-+	}
-+	return 0;
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_hobject *h;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	if (DUK_TVAL_IS_OBJECT(tv)) {
-+		h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+		if (!DUK_HOBJECT_HAS_NATIVEFUNCTION(h)) {
-+			goto type_error;
-+		}
-+		return (duk_int_t) ((duk_hnativefunction *) h)->magic;
-+	} else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
-+		duk_small_uint_t lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
-+		return (duk_int_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
-+	}
-+
-+	/* fall through */
-+ type_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE);
-+	return 0;
-+}
-+
-+DUK_EXTERNAL void duk_set_magic(duk_context *ctx, duk_idx_t index, duk_int_t magic) {
-+	duk_hnativefunction *nf;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	nf = duk_require_hnativefunction(ctx, index);
-+	DUK_ASSERT(nf != NULL);
-+	nf->magic = (duk_int16_t) magic;
-+}
-+#line 1 "duk_api_codec.c"
-+/*
-+ *  Encoding and decoding basic formats: hex, base64.
-+ *
-+ *  These are in-place operations which may allow an optimized implementation.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* dst length must be exactly ceil(len/3)*4 */
-+DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, const duk_uint8_t *src_end,
-+                                         duk_uint8_t *dst, duk_uint8_t *dst_end) {
-+	duk_small_uint_t i, snip;
-+	duk_uint_fast32_t t;
-+	duk_uint_fast8_t x, y;
-+
-+	DUK_UNREF(dst_end);
-+
-+	while (src < src_end) {
-+		/* read 3 bytes into 't', padded by zero */
-+		snip = 4;
-+		t = 0;
-+		for (i = 0; i < 3; i++) {
-+			t = t << 8;
-+			if (src >= src_end) {
-+				snip--;
-+			} else {
-+				t += (duk_uint_fast32_t) (*src++);
-+			}
-+		}
-+
-+		/*
-+		 *  Missing bytes    snip     base64 example
-+		 *    0               4         XXXX
-+		 *    1               3         XXX=
-+		 *    2               2         XX==
-+		 */
-+
-+		DUK_ASSERT(snip >= 2 && snip <= 4);
-+
-+		for (i = 0; i < 4; i++) {
-+			x = (duk_uint_fast8_t) ((t >> 18) & 0x3f);
-+			t = t << 6;
-+
-+			/* A straightforward 64-byte lookup would be faster
-+			 * and cleaner, but this is shorter.
-+			 */
-+			if (i >= snip) {
-+				y = '=';
-+			} else if (x <= 25) {
-+				y = x + 'A';
-+			} else if (x <= 51) {
-+				y = x - 26 + 'a';
-+			} else if (x <= 61) {
-+				y = x - 52 + '0';
-+			} else if (x == 62) {
-+				y = '+';
-+			} else {
-+				y = '/';
-+			}
-+
-+			DUK_ASSERT(dst < dst_end);
-+			*dst++ = (duk_uint8_t) y;
-+		}
-+	}
-+}
-+
-+DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, const duk_uint8_t *src_end,
-+                                               duk_uint8_t *dst, duk_uint8_t *dst_end, duk_uint8_t **out_dst_final) {
-+	duk_uint_fast32_t t;
-+	duk_uint_fast8_t x, y;
-+	duk_small_uint_t group_idx;
-+
-+	DUK_UNREF(dst_end);
-+
-+	t = 0;
-+	group_idx = 0;
-+
-+	while (src < src_end) {
-+		x = *src++;
-+
-+		if (x >= 'A' && x <= 'Z') {
-+			y = x - 'A' + 0;
-+		} else if (x >= 'a' && x <= 'z') {
-+			y = x - 'a' + 26;
-+		} else if (x >= '0' && x <= '9') {
-+			y = x - '0' + 52;
-+		} else if (x == '+') {
-+			y = 62;
-+		} else if (x == '/') {
-+			y = 63;
-+		} else if (x == '=') {
-+			/* We don't check the zero padding bytes here right now.
-+			 * This seems to be common behavior for base-64 decoders.
-+			 */
-+
-+			if (group_idx == 2) {
-+				/* xx== -> 1 byte, t contains 12 bits, 4 on right are zero */
-+				t = t >> 4;
-+				DUK_ASSERT(dst < dst_end);
-+				*dst++ = (duk_uint8_t) t;
-+
-+				if (src >= src_end) {
-+					goto error;
-+				}
-+				x = *src++;
-+				if (x != '=') {
-+					goto error;
-+				}
-+			} else if (group_idx == 3) {
-+				/* xxx= -> 2 bytes, t contains 18 bits, 2 on right are zero */
-+				t = t >> 2;
-+				DUK_ASSERT(dst < dst_end);
-+				*dst++ = (duk_uint8_t) ((t >> 8) & 0xff);
-+				DUK_ASSERT(dst < dst_end);
-+				*dst++ = (duk_uint8_t) (t & 0xff);
-+			} else {
-+				goto error;
-+			}
-+
-+			/* Here we can choose either to end parsing and ignore
-+			 * whatever follows, or to continue parsing in case
-+			 * multiple (possibly padded) base64 strings have been
-+			 * concatenated.  Currently, keep on parsing.
-+			 */
-+			t = 0;
-+			group_idx = 0;
-+			continue;
-+		} else if (x == 0x09 || x == 0x0a || x == 0x0d || x == 0x20) {
-+			/* allow basic ASCII whitespace */
-+			continue;
-+		} else {
-+			goto error;
-+		}
-+
-+		t = (t << 6) + y;
-+
-+		if (group_idx == 3) {
-+			/* output 3 bytes from 't' */
-+			DUK_ASSERT(dst < dst_end);
-+			*dst++ = (duk_uint8_t) ((t >> 16) & 0xff);
-+			DUK_ASSERT(dst < dst_end);
-+			*dst++ = (duk_uint8_t) ((t >> 8) & 0xff);
-+			DUK_ASSERT(dst < dst_end);
-+			*dst++ = (duk_uint8_t) (t & 0xff);
-+			t = 0;
-+			group_idx = 0;
-+		} else {
-+			group_idx++;
-+		}
-+	}
-+
-+	if (group_idx != 0) {
-+		/* Here we'd have the option of decoding unpadded base64
-+		 * (e.g. "xxxxyy" instead of "xxxxyy==".  Currently not
-+		 * accepted.
-+		 */
-+		goto error;
-+	}
-+
-+	*out_dst_final = dst;
-+	return 1;
-+
-+ error:
-+	return 0;
-+}
-+
-+/* Shared handling for encode/decode argument.  Fast path handling for
-+ * buffer and string values because they're the most common.  In particular,
-+ * avoid creating a temporary string or buffer when possible.
-+ */
-+DUK_LOCAL const duk_uint8_t *duk__prep_codec_arg(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
-+	DUK_ASSERT(duk_is_valid_index(ctx, index));  /* checked by caller */
-+	if (duk_is_buffer(ctx, index)) {
-+		return (const duk_uint8_t *) duk_get_buffer(ctx, index, out_len);
-+	} else {
-+		return (const duk_uint8_t *) duk_to_lstring(ctx, index, out_len);
-+	}
-+}
-+
-+DUK_EXTERNAL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_uint8_t *src;
-+	duk_size_t srclen;
-+	duk_size_t dstlen;
-+	duk_uint8_t *dst;
-+	const char *ret;
-+
-+	/* XXX: optimize for string inputs: no need to coerce to a buffer
-+	 * which makes a copy of the input.
-+	 */
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	src = (duk_uint8_t *) duk_to_buffer(ctx, index, &srclen);
-+	/* Note: for srclen=0, src may be NULL */
-+
-+	/* Computation must not wrap; this limit works for 32-bit size_t:
-+	 * >>> srclen = 3221225469
-+	 * >>> '%x' % ((srclen + 2) / 3 * 4)
-+	 * 'fffffffc'
-+	 */
-+	if (srclen > 3221225469UL) {
-+		goto type_error;
-+	}
-+	dstlen = (srclen + 2) / 3 * 4;
-+	dst = (duk_uint8_t *) duk_push_fixed_buffer(ctx, dstlen);
-+
-+	duk__base64_encode_helper((const duk_uint8_t *) src, (const duk_uint8_t *) (src + srclen),
-+	                          dst, (dst + dstlen));
-+
-+	ret = duk_to_string(ctx, -1);
-+	duk_replace(ctx, index);
-+	return ret;
-+
-+ type_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_BASE64_ENCODE_FAILED);
-+	return NULL;  /* never here */
-+}
-+
-+DUK_EXTERNAL void duk_base64_decode(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	const duk_uint8_t *src;
-+	duk_size_t srclen;
-+	duk_size_t dstlen;
-+	duk_uint8_t *dst;
-+	duk_uint8_t *dst_final;
-+	duk_bool_t retval;
-+
-+	/* XXX: optimize for buffer inputs: no need to coerce to a string
-+	 * which causes an unnecessary interning.
-+	 */
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	src = (const duk_uint8_t *) duk_to_lstring(ctx, index, &srclen);
-+
-+	/* Computation must not wrap, only srclen + 3 is at risk of
-+	 * wrapping because after that the number gets smaller.
-+	 * This limit works for 32-bit size_t:
-+	 * 0x100000000 - 3 - 1 = 4294967292
-+	 */
-+	if (srclen > 4294967292UL) {
-+		goto type_error;
-+	}
-+	dstlen = (srclen + 3) / 4 * 3;  /* upper limit */
-+	dst = (duk_uint8_t *) duk_push_dynamic_buffer(ctx, dstlen);
-+	/* Note: for dstlen=0, dst may be NULL */
-+
-+	retval = duk__base64_decode_helper((const duk_uint8_t *) src, (const duk_uint8_t *) (src + srclen),
-+	                                   dst, dst + dstlen, &dst_final);
-+	if (!retval) {
-+		goto type_error;
-+	}
-+
-+	/* XXX: convert to fixed buffer? */
-+	(void) duk_resize_buffer(ctx, -1, (duk_size_t) (dst_final - dst));
-+	duk_replace(ctx, index);
-+	return;
-+
-+ type_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_BASE64_DECODE_FAILED);
-+}
-+
-+DUK_EXTERNAL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index) {
-+	const duk_uint8_t *inp;
-+	duk_size_t len;
-+	duk_size_t i;
-+	duk_small_uint_t t;
-+	duk_uint8_t *buf;
-+	const char *ret;
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	inp = duk__prep_codec_arg(ctx, index, &len);
-+	DUK_ASSERT(inp != NULL || len == 0);
-+
-+	/* Fixed buffer, no zeroing because we'll fill all the data. */
-+	buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len * 2, DUK_BUF_FLAG_NOZERO /*flags*/);
-+	DUK_ASSERT(buf != NULL);
-+
-+	for (i = 0; i < len; i++) {
-+		/* XXX: by using two 256-entry tables could avoid shifting and masking. */
-+		t = (duk_small_uint_t) inp[i];
-+		buf[i*2 + 0] = duk_lc_digits[t >> 4];
-+		buf[i*2 + 1] = duk_lc_digits[t & 0x0f];
-+	}
-+
-+	/* XXX: Using a string return value forces a string intern which is
-+	 * not always necessary.  As a rough performance measure, hex encode
-+	 * time for perf-testcases/test-hex-encode.js dropped from ~35s to
-+	 * ~15s without string coercion.  Change to returning a buffer and
-+	 * let the caller coerce to string if necessary?
-+	 */
-+
-+	ret = duk_to_string(ctx, -1);
-+	duk_replace(ctx, index);
-+	return ret;
-+}
-+
-+DUK_EXTERNAL void duk_hex_decode(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	const duk_uint8_t *inp;
-+	duk_size_t len;
-+	duk_size_t i;
-+	duk_small_int_t t;
-+	duk_uint8_t *buf;
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	inp = duk__prep_codec_arg(ctx, index, &len);
-+	DUK_ASSERT(inp != NULL || len == 0);
-+
-+	if (len & 0x01) {
-+		goto type_error;
-+	}
-+
-+	/* Fixed buffer, no zeroing because we'll fill all the data. */
-+	buf = (duk_uint8_t *) duk_push_buffer_raw(ctx, len / 2, DUK_BUF_FLAG_NOZERO /*flags*/);
-+	DUK_ASSERT(buf != NULL);
-+
-+	for (i = 0; i < len; i += 2) {
-+		/* For invalid characters the value -1 gets extended to
-+		 * at least 16 bits.  If either nybble is invalid, the
-+		 * resulting 't' will be < 0.
-+		 */
-+		t = (((duk_small_int_t) duk_hex_dectab[inp[i]]) << 4) |
-+		    ((duk_small_int_t) duk_hex_dectab[inp[i + 1]]);
-+		if (DUK_UNLIKELY(t < 0)) {
-+			goto type_error;
-+		}
-+		buf[i >> 1] = (duk_uint8_t) t;
-+	}
-+
-+	duk_replace(ctx, index);
-+	return;
-+
-+ type_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_HEX_DECODE_FAILED);
-+}
-+
-+DUK_EXTERNAL const char *duk_json_encode(duk_context *ctx, duk_idx_t index) {
-+#ifdef DUK_USE_ASSERTIONS
-+	duk_idx_t top_at_entry = duk_get_top(ctx);
-+#endif
-+	const char *ret;
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	duk_bi_json_stringify_helper(ctx,
-+	                             index /*idx_value*/,
-+	                             DUK_INVALID_INDEX /*idx_replacer*/,
-+	                             DUK_INVALID_INDEX /*idx_space*/,
-+	                             0 /*flags*/);
-+	DUK_ASSERT(duk_is_string(ctx, -1));
-+	duk_replace(ctx, index);
-+	ret = duk_get_string(ctx, index);
-+
-+	DUK_ASSERT(duk_get_top(ctx) == top_at_entry);
-+
-+	return ret;
-+}
-+
-+DUK_EXTERNAL void duk_json_decode(duk_context *ctx, duk_idx_t index) {
-+#ifdef DUK_USE_ASSERTIONS
-+	duk_idx_t top_at_entry = duk_get_top(ctx);
-+#endif
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	duk_bi_json_parse_helper(ctx,
-+	                         index /*idx_value*/,
-+	                         DUK_INVALID_INDEX /*idx_reviver*/,
-+	                         0 /*flags*/);
-+	duk_replace(ctx, index);
-+
-+	DUK_ASSERT(duk_get_top(ctx) == top_at_entry);
-+}
-+#line 1 "duk_api_compile.c"
-+/*
-+ *  Compilation and evaluation
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+typedef struct duk__compile_raw_args duk__compile_raw_args;
-+struct duk__compile_raw_args {
-+	duk_size_t src_length;  /* should be first on 64-bit platforms */
-+	const duk_uint8_t *src_buffer;
-+	duk_uint_t flags;
-+};
-+
-+/* Eval is just a wrapper now. */
-+DUK_EXTERNAL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags) {
-+	duk_uint_t comp_flags;
-+	duk_int_t rc;
-+
-+	/* Note: strictness is *not* inherited from the current Duktape/C.
-+	 * This would be confusing because the current strictness state
-+	 * depends on whether we're running inside a Duktape/C activation
-+	 * (= strict mode) or outside of any activation (= non-strict mode).
-+	 * See api-testcases/test-eval-strictness.c for more discussion.
-+	 */
-+
-+	/* [ ... source? filename ] (depends on flags) */
-+
-+	comp_flags = flags;
-+	comp_flags |= DUK_COMPILE_EVAL;
-+	rc = duk_compile_raw(ctx, src_buffer, src_length, comp_flags);  /* may be safe, or non-safe depending on flags */
-+
-+	/* [ ... closure/error ] */
-+
-+	if (rc != DUK_EXEC_SUCCESS) {
-+		rc = DUK_EXEC_ERROR;
-+		goto got_rc;
-+	}
-+
-+	if (flags & DUK_COMPILE_SAFE) {
-+		rc = duk_pcall(ctx, 0);
-+	} else {
-+		duk_call(ctx, 0);
-+		rc = DUK_EXEC_SUCCESS;
-+	}
-+
-+	/* [ ... result/error ] */
-+
-+ got_rc:
-+	if (flags & DUK_COMPILE_NORESULT) {
-+		duk_pop(ctx);
-+	}
-+
-+	return rc;
-+}
-+
-+/* Helper which can be called both directly and with duk_safe_call(). */
-+DUK_LOCAL duk_ret_t duk__do_compile(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk__compile_raw_args *comp_args;
-+	duk_uint_t flags;
-+	duk_small_uint_t comp_flags;
-+	duk_hcompiledfunction *h_templ;
-+
-+	/* Note: strictness is not inherited from the current Duktape/C
-+	 * context.  Otherwise it would not be possible to compile
-+	 * non-strict code inside a Duktape/C activation (which is
-+	 * always strict now).  See api-testcases/test-eval-strictness.c
-+	 * for discussion.
-+	 */
-+
-+	/* [ ... source? filename &comp_args ] (depends on flags) */
-+
-+	comp_args = (duk__compile_raw_args *) duk_require_pointer(ctx, -1);
-+	flags = comp_args->flags;
-+	duk_pop(ctx);
-+
-+	/* [ ... source? filename ] */
-+
-+	if (!comp_args->src_buffer) {
-+		duk_hstring *h_sourcecode;
-+
-+		h_sourcecode = duk_get_hstring(ctx, -2);
-+		if ((flags & DUK_COMPILE_NOSOURCE) ||  /* args incorrect */
-+		    (h_sourcecode == NULL)) {          /* e.g. duk_push_file_string_raw() pushed undefined */
-+			/* XXX: when this error is caused by a nonexistent
-+			 * file given to duk_peval_file() or similar, the
-+			 * error message is not the best possible.
-+			 */
-+			DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_NO_SOURCECODE);
-+		}
-+		DUK_ASSERT(h_sourcecode != NULL);
-+		comp_args->src_buffer = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode);
-+		comp_args->src_length = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode);
-+	}
-+	DUK_ASSERT(comp_args->src_buffer != NULL);
-+
-+	/* XXX: unnecessary translation of flags */
-+	comp_flags = 0;
-+	if (flags & DUK_COMPILE_EVAL) {
-+		comp_flags |= DUK_JS_COMPILE_FLAG_EVAL;
-+	}
-+	if (flags & DUK_COMPILE_FUNCTION) {
-+		comp_flags |= DUK_JS_COMPILE_FLAG_EVAL |
-+		              DUK_JS_COMPILE_FLAG_FUNCEXPR;
-+	}
-+	if (flags & DUK_COMPILE_STRICT) {
-+		comp_flags |= DUK_JS_COMPILE_FLAG_STRICT;
-+	}
-+
-+	/* [ ... source? filename ] */
-+
-+	duk_js_compile(thr, comp_args->src_buffer, comp_args->src_length, comp_flags);
-+
-+	/* [ ... source? func_template ] */
-+
-+	if (flags & DUK_COMPILE_NOSOURCE) {
-+		;
-+	} else {
-+		duk_remove(ctx, -2);
-+	}
-+
-+	/* [ ... func_template ] */
-+
-+	h_templ = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(h_templ != NULL);
-+	duk_js_push_closure(thr,
-+	                   h_templ,
-+	                   thr->builtins[DUK_BIDX_GLOBAL_ENV],
-+	                   thr->builtins[DUK_BIDX_GLOBAL_ENV]);
-+	duk_remove(ctx, -2);   /* -> [ ... closure ] */
-+
-+	/* [ ... closure ] */
-+
-+	return 1;
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags) {
-+	duk__compile_raw_args comp_args_alloc;
-+	duk__compile_raw_args *comp_args = &comp_args_alloc;
-+
-+	if ((flags & DUK_COMPILE_STRLEN) && (src_buffer != NULL)) {
-+		/* String length is computed here to avoid multiple evaluation
-+		 * of a macro argument in the calling side.
-+		 */
-+		src_length = DUK_STRLEN(src_buffer);
-+	}
-+
-+	comp_args->src_buffer = (const duk_uint8_t *) src_buffer;
-+	comp_args->src_length = src_length;
-+	comp_args->flags = flags;
-+	duk_push_pointer(ctx, (void *) comp_args);
-+
-+	/* [ ... source? filename &comp_args ] (depends on flags) */
-+
-+	if (flags & DUK_COMPILE_SAFE) {
-+		duk_int_t rc;
-+		duk_int_t nargs;
-+		duk_int_t nrets = 1;
-+
-+		/* Arguments are either: [ filename &comp_args ] or [ source filename &comp_args ] */
-+		nargs = (flags & DUK_COMPILE_NOSOURCE) ? 2 : 3;
-+		rc = duk_safe_call(ctx, duk__do_compile, nargs, nrets);
-+
-+		/* [ ... closure ] */
-+		return rc;
-+	}
-+
-+	(void) duk__do_compile(ctx);
-+
-+	/* [ ... closure ] */
-+	return DUK_EXEC_SUCCESS;
-+}
-+#line 1 "duk_api_debug.c"
-+/*
-+ *  Debugging related API calls
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_EXTERNAL void duk_push_context_dump(duk_context *ctx) {
-+	duk_idx_t idx;
-+	duk_idx_t top;
-+
-+	/* We don't duk_require_stack() here now, but rely on the caller having
-+	 * enough space.
-+	 */
-+
-+	top = duk_get_top(ctx);
-+	duk_push_array(ctx);
-+	for (idx = 0; idx < top; idx++) {
-+		duk_dup(ctx, idx);
-+		duk_put_prop_index(ctx, -2, idx);
-+	}
-+
-+	/* XXX: conversion errors should not propagate outwards.
-+	 * Perhaps values need to be coerced individually?
-+	 */
-+	duk_bi_json_stringify_helper(ctx,
-+	                             duk_get_top_index(ctx),  /*idx_value*/
-+	                             DUK_INVALID_INDEX,  /*idx_replacer*/
-+	                             DUK_INVALID_INDEX,  /*idx_space*/
-+	                             DUK_JSON_FLAG_EXT_CUSTOM |
-+	                             DUK_JSON_FLAG_ASCII_ONLY |
-+	                             DUK_JSON_FLAG_AVOID_KEY_QUOTES /*flags*/);
-+
-+	duk_push_sprintf(ctx, "ctx: top=%ld, stack=%s", (long) top, (const char *) duk_safe_to_string(ctx, -1));
-+	duk_replace(ctx, -3);  /* [ ... arr jsonx(arr) res ] -> [ ... res jsonx(arr) ] */
-+	duk_pop(ctx);
-+	DUK_ASSERT(duk_is_string(ctx, -1));
-+}
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+
-+DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx,
-+                                      duk_debug_read_function read_cb,
-+                                      duk_debug_write_function write_cb,
-+                                      duk_debug_peek_function peek_cb,
-+                                      duk_debug_read_flush_function read_flush_cb,
-+                                      duk_debug_write_flush_function write_flush_cb,
-+                                      duk_debug_detached_function detached_cb,
-+                                      void *udata) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_heap *heap;
-+	const char *str;
-+	duk_size_t len;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(read_cb != NULL);
-+	DUK_ASSERT(write_cb != NULL);
-+	/* Other callbacks are optional. */
-+
-+	heap = thr->heap;
-+	heap->dbg_read_cb = read_cb;
-+	heap->dbg_write_cb = write_cb;
-+	heap->dbg_peek_cb = peek_cb;
-+	heap->dbg_read_flush_cb = read_flush_cb;
-+	heap->dbg_write_flush_cb = write_flush_cb;
-+	heap->dbg_detached_cb = detached_cb;
-+	heap->dbg_udata = udata;
-+
-+	/* Start in paused state. */
-+	heap->dbg_processing = 0;
-+	heap->dbg_paused = 1;
-+	heap->dbg_state_dirty = 1;
-+	heap->dbg_step_type = 0;
-+	heap->dbg_step_thread = NULL;
-+	heap->dbg_step_csindex = 0;
-+	heap->dbg_step_startline = 0;
-+	heap->dbg_exec_counter = 0;
-+	heap->dbg_last_counter = 0;
-+	heap->dbg_last_time = 0.0;
-+
-+	/* Send version identification and flush right afterwards.  Note that
-+	 * we must write raw, unframed bytes here.
-+	 */
-+	duk_push_sprintf(ctx, "%ld %ld %s %s\n",
-+	                 (long) DUK_DEBUG_PROTOCOL_VERSION,
-+	                 (long) DUK_VERSION,
-+	                 (const char *) DUK_GIT_DESCRIBE,
-+	                 (const char *) DUK_USE_TARGET_INFO);
-+	str = duk_get_lstring(ctx, -1, &len);
-+	DUK_ASSERT(str != NULL);
-+	duk_debug_write_bytes(thr, (const duk_uint8_t *) str, len);
-+	duk_debug_write_flush(thr);
-+	duk_pop(ctx);
-+}
-+
-+DUK_EXTERNAL void duk_debugger_detach(duk_context *ctx) {
-+	duk_hthread *thr;
-+
-+	thr = (duk_hthread *) ctx;
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+
-+	/* Can be called muliple times with no harm. */
-+	duk_debug_do_detach(thr->heap);
-+}
-+
-+DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx) {
-+	duk_hthread *thr;
-+	duk_bool_t processed_messages;
-+
-+	thr = (duk_hthread *) ctx;
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+
-+	if (!DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
-+		return;
-+	}
-+	if (thr->callstack_top > 0 || thr->heap->dbg_processing) {
-+		/* Calling duk_debugger_cooperate() while Duktape is being
-+		 * called into is not supported.  This is not a 100% check
-+		 * but prevents any damage in most cases.
-+		 */
-+		return;
-+	}
-+
-+	thr->heap->dbg_processing = 1;
-+	processed_messages = duk_debug_process_messages(thr, 1 /*no_block*/);
-+	thr->heap->dbg_processing = 0;
-+	DUK_UNREF(processed_messages);
-+}
-+
-+#else  /* DUK_USE_DEBUGGER_SUPPORT */
-+
-+DUK_EXTERNAL void duk_debugger_attach(duk_context *ctx,
-+                                      duk_debug_read_function read_cb,
-+                                      duk_debug_write_function write_cb,
-+                                      duk_debug_peek_function peek_cb,
-+                                      duk_debug_read_flush_function read_flush_cb,
-+                                      duk_debug_write_flush_function write_flush_cb,
-+                                      duk_debug_detached_function detached_cb,
-+                                      void *udata) {
-+	DUK_UNREF(read_cb);
-+	DUK_UNREF(write_cb);
-+	DUK_UNREF(peek_cb);
-+	DUK_UNREF(read_flush_cb);
-+	DUK_UNREF(write_flush_cb);
-+	DUK_UNREF(detached_cb);
-+	DUK_UNREF(udata);
-+	duk_error(ctx, DUK_ERR_API_ERROR, "no debugger support");
-+}
-+
-+DUK_EXTERNAL void duk_debugger_detach(duk_context *ctx) {
-+	duk_error(ctx, DUK_ERR_API_ERROR, "no debugger support");
-+}
-+
-+DUK_EXTERNAL void duk_debugger_cooperate(duk_context *ctx) {
-+	/* nop */
-+	DUK_UNREF(ctx);
-+}
-+
-+#endif  /* DUK_USE_DEBUGGER_SUPPORT */
-+#line 1 "duk_api_heap.c"
-+/*
-+ *  Heap creation and destruction
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_EXTERNAL
-+duk_context *duk_create_heap(duk_alloc_function alloc_func,
-+                             duk_realloc_function realloc_func,
-+                             duk_free_function free_func,
-+                             void *heap_udata,
-+                             duk_fatal_function fatal_handler) {
-+	duk_heap *heap = NULL;
-+	duk_context *ctx;
-+
-+	/* Assume that either all memory funcs are NULL or non-NULL, mixed
-+	 * cases will now be unsafe.
-+	 */
-+
-+	/* XXX: just assert non-NULL values here and make caller arguments
-+	 * do the defaulting to the default implementations (smaller code)?
-+	 */
-+
-+	if (!alloc_func) {
-+		DUK_ASSERT(realloc_func == NULL);
-+		DUK_ASSERT(free_func == NULL);
-+		alloc_func = duk_default_alloc_function;
-+		realloc_func = duk_default_realloc_function;
-+		free_func = duk_default_free_function;
-+	} else {
-+		DUK_ASSERT(realloc_func != NULL);
-+		DUK_ASSERT(free_func != NULL);
-+	}
-+
-+	if (!fatal_handler) {
-+		fatal_handler = duk_default_fatal_handler;
-+	}
-+
-+	DUK_ASSERT(alloc_func != NULL);
-+	DUK_ASSERT(realloc_func != NULL);
-+	DUK_ASSERT(free_func != NULL);
-+	DUK_ASSERT(fatal_handler != NULL);
-+
-+	heap = duk_heap_alloc(alloc_func, realloc_func, free_func, heap_udata, fatal_handler);
-+	if (!heap) {
-+		return NULL;
-+	}
-+	ctx = (duk_context *) heap->heap_thread;
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(((duk_hthread *) ctx)->heap != NULL);
-+	return ctx;
-+}
-+
-+DUK_EXTERNAL void duk_destroy_heap(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_heap *heap;
-+
-+	if (!ctx) {
-+		return;
-+	}
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	duk_heap_free(heap);
-+}
-+
-+/* XXX: better place for this */
-+DUK_EXTERNAL void duk_set_global_object(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h_glob;
-+	duk_hobject *h_prev_glob;
-+	duk_hobject *h_env;
-+	duk_hobject *h_prev_env;
-+
-+	DUK_D(DUK_DPRINT("replace global object with: %!T", duk_get_tval(ctx, -1)));
-+
-+	h_glob = duk_require_hobject(ctx, -1);
-+	DUK_ASSERT(h_glob != NULL);
-+
-+	/*
-+	 *  Replace global object.
-+	 */
-+
-+	h_prev_glob = thr->builtins[DUK_BIDX_GLOBAL];
-+	thr->builtins[DUK_BIDX_GLOBAL] = h_glob;
-+	DUK_HOBJECT_INCREF(thr, h_glob);
-+	DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_prev_glob);  /* side effects, in theory (referenced by global env) */
-+
-+	/*
-+	 *  Replace lexical environment for global scope
-+	 *
-+	 *  Create a new object environment for the global lexical scope.
-+	 *  We can't just reset the _Target property of the current one,
-+	 *  because the lexical scope is shared by other threads with the
-+	 *  same (initial) built-ins.
-+	 */
-+
-+	(void) duk_push_object_helper(ctx,
-+	                              DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                              DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV),
-+	                              -1);  /* no prototype, updated below */
-+
-+	duk_dup(ctx, -2);
-+	duk_dup(ctx, -3);
-+
-+	/* [ ... new_glob new_env new_glob new_glob ] */
-+
-+	duk_xdef_prop_stridx(thr, -3, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
-+	duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE);
-+
-+	/* [ ... new_glob new_env ] */
-+
-+	h_env = duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(h_env != NULL);
-+
-+	h_prev_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+	thr->builtins[DUK_BIDX_GLOBAL_ENV] = h_env;
-+	DUK_HOBJECT_INCREF(thr, h_env);
-+	DUK_HOBJECT_DECREF_ALLOWNULL(thr, h_prev_env);  /* side effects */
-+	DUK_UNREF(h_env);  /* without refcounts */
-+	DUK_UNREF(h_prev_env);
-+
-+	/* [ ... new_glob new_env ] */
-+
-+	duk_pop_2(ctx);
-+
-+	/* [ ... ] */
-+}
-+#line 1 "duk_api_logging.c"
-+/*
-+ *  Logging
-+ *
-+ *  Current logging primitive is a sprintf-style log which is convenient
-+ *  for most C code.  Another useful primitive would be to log N arguments
-+ *  from value stack (like the Ecmascript binding does).
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_EXTERNAL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, va_list ap) {
-+	/* stridx_logfunc[] must be static to allow initializer with old compilers like BCC */
-+	static const duk_uint16_t stridx_logfunc[6] = {
-+		DUK_STRIDX_LC_TRACE, DUK_STRIDX_LC_DEBUG, DUK_STRIDX_LC_INFO,
-+		DUK_STRIDX_LC_WARN, DUK_STRIDX_LC_ERROR, DUK_STRIDX_LC_FATAL
-+	};
-+
-+	if (level < 0) {
-+		level = 0;
-+	} else if (level > (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1) {
-+		level = (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1;
-+	}
-+
-+	duk_push_hobject_bidx(ctx, DUK_BIDX_LOGGER_CONSTRUCTOR);
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_CLOG);
-+	duk_get_prop_stridx(ctx, -1, stridx_logfunc[level]);
-+	duk_dup(ctx, -2);
-+
-+	/* [ ... Logger clog logfunc clog ] */
-+
-+	duk_push_vsprintf(ctx, fmt, ap);
-+
-+	/* [ ... Logger clog logfunc clog(=this) msg ] */
-+
-+	duk_call_method(ctx, 1 /*nargs*/);
-+
-+	/* [ ... Logger clog res ] */
-+
-+	duk_pop_3(ctx);
-+}
-+
-+DUK_EXTERNAL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...) {
-+	va_list ap;
-+
-+	va_start(ap, fmt);
-+	duk_log_va(ctx, level, fmt, ap);
-+	va_end(ap);
-+}
-+#line 1 "duk_api_memory.c"
-+/*
-+ *  Memory calls.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_EXTERNAL void *duk_alloc_raw(duk_context *ctx, duk_size_t size) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	return DUK_ALLOC_RAW(thr->heap, size);
-+}
-+
-+DUK_EXTERNAL void duk_free_raw(duk_context *ctx, void *ptr) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	DUK_FREE_RAW(thr->heap, ptr);
-+}
-+
-+DUK_EXTERNAL void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	return DUK_REALLOC_RAW(thr->heap, ptr, size);
-+}
-+
-+DUK_EXTERNAL void *duk_alloc(duk_context *ctx, duk_size_t size) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	return DUK_ALLOC(thr->heap, size);
-+}
-+
-+DUK_EXTERNAL void duk_free(duk_context *ctx, void *ptr) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	DUK_FREE(thr->heap, ptr);
-+}
-+
-+DUK_EXTERNAL void *duk_realloc(duk_context *ctx, void *ptr, duk_size_t size) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/*
-+	 *  Note: since this is an exposed API call, there should be
-+	 *  no way a mark-and-sweep could have a side effect on the
-+	 *  memory allocation behind 'ptr'; the pointer should never
-+	 *  be something that Duktape wants to change.
-+	 *
-+	 *  Thus, no need to use DUK_REALLOC_INDIRECT (and we don't
-+	 *  have the storage location here anyway).
-+	 */
-+
-+	return DUK_REALLOC(thr->heap, ptr, size);
-+}
-+
-+DUK_EXTERNAL void duk_get_memory_functions(duk_context *ctx, duk_memory_functions *out_funcs) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_heap *heap;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(out_funcs != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+
-+	heap = thr->heap;
-+	out_funcs->alloc_func = heap->alloc_func;
-+	out_funcs->realloc_func = heap->realloc_func;
-+	out_funcs->free_func = heap->free_func;
-+	out_funcs->udata = heap->heap_udata;
-+}
-+
-+DUK_EXTERNAL void duk_gc(duk_context *ctx, duk_uint_t flags) {
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_heap *heap;
-+
-+	DUK_UNREF(flags);
-+
-+	if (!ctx) {
-+		return;
-+	}
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	DUK_D(DUK_DPRINT("mark-and-sweep requested by application"));
-+	duk_heap_mark_and_sweep(heap, 0);
-+#else
-+	DUK_D(DUK_DPRINT("mark-and-sweep requested by application but mark-and-sweep not enabled, ignoring"));
-+	DUK_UNREF(ctx);
-+	DUK_UNREF(flags);
-+#endif
-+}
-+#line 1 "duk_api_object.c"
-+/*
-+ *  Object handling: property access and other support functions.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Property handling
-+ *
-+ *  The API exposes only the most common property handling functions.
-+ *  The caller can invoke Ecmascript built-ins for full control (e.g.
-+ *  defineProperty, getOwnPropertyDescriptor).
-+ */
-+
-+DUK_EXTERNAL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv_obj;
-+	duk_tval *tv_key;
-+	duk_bool_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* Note: copying tv_obj and tv_key to locals to shield against a valstack
-+	 * resize is not necessary for a property get right now.
-+	 */
-+
-+	tv_obj = duk_require_tval(ctx, obj_index);
-+	tv_key = duk_require_tval(ctx, -1);
-+
-+	rc = duk_hobject_getprop(thr, tv_obj, tv_key);
-+	DUK_ASSERT(rc == 0 || rc == 1);
-+	/* a value is left on stack regardless of rc */
-+
-+	duk_remove(ctx, -2);  /* remove key */
-+	return rc;  /* 1 if property found, 0 otherwise */
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) {
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_string(ctx, key);
-+	return duk_get_prop(ctx, obj_index);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_uarridx(ctx, arr_index);
-+	return duk_get_prop(ctx, obj_index);
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(stridx >= 0);
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
-+	return duk_get_prop(ctx, obj_index);
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_get_prop_stridx_boolean(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_bool_t *out_has_prop) {
-+	duk_bool_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(stridx >= 0);
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+
-+	rc = duk_get_prop_stridx(ctx, obj_index, stridx);
-+	if (out_has_prop) {
-+		*out_has_prop = rc;
-+	}
-+	rc = duk_to_boolean(ctx, -1);
-+	DUK_ASSERT(rc == 0 || rc == 1);
-+	duk_pop(ctx);
-+	return rc;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv_obj;
-+	duk_tval *tv_key;
-+	duk_tval *tv_val;
-+	duk_small_int_t throw_flag;
-+	duk_bool_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* Note: copying tv_obj and tv_key to locals to shield against a valstack
-+	 * resize is not necessary for a property put right now (putprop protects
-+	 * against it internally).
-+	 */
-+
-+	tv_obj = duk_require_tval(ctx, obj_index);
-+	tv_key = duk_require_tval(ctx, -2);
-+	tv_val = duk_require_tval(ctx, -1);
-+	throw_flag = duk_is_strict_call(ctx);
-+
-+	rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, throw_flag);
-+	DUK_ASSERT(rc == 0 || rc == 1);
-+
-+	duk_pop_2(ctx);  /* remove key and value */
-+	return rc;  /* 1 if property found, 0 otherwise */
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) {
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_string(ctx, key);
-+	duk_swap_top(ctx, -2);  /* [val key] -> [key val] */
-+	return duk_put_prop(ctx, obj_index);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_uarridx(ctx, arr_index);
-+	duk_swap_top(ctx, -2);  /* [val key] -> [key val] */
-+	return duk_put_prop(ctx, obj_index);
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(stridx >= 0);
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
-+	duk_swap_top(ctx, -2);  /* [val key] -> [key val] */
-+	return duk_put_prop(ctx, obj_index);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv_obj;
-+	duk_tval *tv_key;
-+	duk_small_int_t throw_flag;
-+	duk_bool_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* Note: copying tv_obj and tv_key to locals to shield against a valstack
-+	 * resize is not necessary for a property delete right now.
-+	 */
-+
-+	tv_obj = duk_require_tval(ctx, obj_index);
-+	tv_key = duk_require_tval(ctx, -1);
-+	throw_flag = duk_is_strict_call(ctx);
-+
-+	rc = duk_hobject_delprop(thr, tv_obj, tv_key, throw_flag);
-+	DUK_ASSERT(rc == 0 || rc == 1);
-+
-+	duk_pop(ctx);  /* remove key */
-+	return rc;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) {
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_string(ctx, key);
-+	return duk_del_prop(ctx, obj_index);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_uarridx(ctx, arr_index);
-+	return duk_del_prop(ctx, obj_index);
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_del_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(stridx >= 0);
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
-+	return duk_del_prop(ctx, obj_index);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv_obj;
-+	duk_tval *tv_key;
-+	duk_bool_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* Note: copying tv_obj and tv_key to locals to shield against a valstack
-+	 * resize is not necessary for a property existence check right now.
-+	 */
-+
-+	tv_obj = duk_require_tval(ctx, obj_index);
-+	tv_key = duk_require_tval(ctx, -1);
-+
-+	rc = duk_hobject_hasprop(thr, tv_obj, tv_key);
-+	DUK_ASSERT(rc == 0 || rc == 1);
-+
-+	duk_pop(ctx);  /* remove key */
-+	return rc;  /* 1 if property found, 0 otherwise */
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key) {
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_string(ctx, key);
-+	return duk_has_prop(ctx, obj_index);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_uarridx(ctx, arr_index);
-+	return duk_has_prop(ctx, obj_index);
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_has_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(stridx >= 0);
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
-+	return duk_has_prop(ctx, obj_index);
-+}
-+
-+/* Define own property without inheritance looks and such.  This differs from
-+ * [[DefineOwnProperty]] because special behaviors (like Array 'length') are
-+ * not invoked by this method.  The caller must be careful to invoke any such
-+ * behaviors if necessary.
-+ */
-+DUK_INTERNAL void duk_xdef_prop(duk_context *ctx, duk_idx_t obj_index, duk_small_uint_t desc_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+	duk_hstring *key;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj = duk_require_hobject(ctx, obj_index);
-+	DUK_ASSERT(obj != NULL);
-+	key = duk_to_hstring(ctx, -2);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(duk_require_tval(ctx, -1) != NULL);
-+
-+	duk_hobject_define_property_internal(thr, obj, key, desc_flags);
-+
-+	duk_pop(ctx);  /* pop key */
-+}
-+
-+DUK_INTERNAL void duk_xdef_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index, duk_small_uint_t desc_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj = duk_require_hobject(ctx, obj_index);
-+	DUK_ASSERT(obj != NULL);
-+
-+	duk_hobject_define_property_internal_arridx(thr, obj, arr_index, desc_flags);
-+	/* value popped by call */
-+}
-+
-+DUK_INTERNAL void duk_xdef_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+	duk_hstring *key;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(stridx >= 0);
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+
-+	obj = duk_require_hobject(ctx, obj_index);
-+	DUK_ASSERT(obj != NULL);
-+	key = DUK_HTHREAD_GET_STRING(thr, stridx);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(duk_require_tval(ctx, -1) != NULL);
-+
-+	duk_hobject_define_property_internal(thr, obj, key, desc_flags);
-+	/* value popped by call */
-+}
-+
-+DUK_INTERNAL void duk_xdef_prop_stridx_builtin(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_int_t builtin_idx, duk_small_uint_t desc_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+	duk_hstring *key;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(stridx >= 0);
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+	DUK_ASSERT_DISABLE(builtin_idx >= 0);
-+	DUK_ASSERT(builtin_idx < DUK_NUM_BUILTINS);
-+
-+	obj = duk_require_hobject(ctx, obj_index);
-+	DUK_ASSERT(obj != NULL);
-+	key = DUK_HTHREAD_GET_STRING(thr, stridx);
-+	DUK_ASSERT(key != NULL);
-+
-+	duk_push_hobject(ctx, thr->builtins[builtin_idx]);
-+	duk_hobject_define_property_internal(thr, obj, key, desc_flags);
-+	/* value popped by call */
-+}
-+
-+/* This is a rare property helper; it sets the global thrower (E5 Section 13.2.3)
-+ * setter/getter into an object property.  This is needed by the 'arguments'
-+ * object creation code, function instance creation code, and Function.prototype.bind().
-+ */
-+
-+DUK_INTERNAL void duk_xdef_prop_stridx_thrower(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj = duk_require_hobject(ctx, obj_index);
-+	duk_hobject *thrower = thr->builtins[DUK_BIDX_TYPE_ERROR_THROWER];
-+	duk_hobject_define_accessor_internal(thr, obj, DUK_HTHREAD_GET_STRING(thr, stridx), thrower, thrower, desc_flags);
-+}
-+
-+/* Object.defineProperty() equivalent C binding. */
-+DUK_EXTERNAL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t idx_base;
-+	duk_hobject *obj;
-+	duk_hstring *key;
-+	duk_idx_t idx_value;
-+	duk_hobject *get;
-+	duk_hobject *set;
-+	duk_uint_t is_data_desc;
-+	duk_uint_t is_acc_desc;
-+
-+	obj = duk_require_hobject(ctx, obj_index);
-+
-+	is_data_desc = flags & (DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_HAVE_WRITABLE);
-+	is_acc_desc = flags & (DUK_DEFPROP_HAVE_GETTER | DUK_DEFPROP_HAVE_SETTER);
-+	if (is_data_desc && is_acc_desc) {
-+		/* "Have" flags must not be conflicting so that they would
-+		 * apply to both a plain property and an accessor at the same
-+		 * time.
-+		 */
-+		goto fail_invalid_desc;
-+	}
-+
-+	idx_base = duk_get_top_index(ctx);
-+	if (flags & DUK_DEFPROP_HAVE_SETTER) {
-+		duk_require_type_mask(ctx, idx_base, DUK_TYPE_MASK_UNDEFINED |
-+		                                     DUK_TYPE_MASK_OBJECT |
-+		                                     DUK_TYPE_MASK_LIGHTFUNC);
-+		set = duk_get_hobject_or_lfunc_coerce(ctx, idx_base);
-+		if (set != NULL && !DUK_HOBJECT_IS_CALLABLE(set)) {
-+			goto fail_not_callable;
-+		}
-+		idx_base--;
-+	} else {
-+		set = NULL;
-+	}
-+	if (flags & DUK_DEFPROP_HAVE_GETTER) {
-+		duk_require_type_mask(ctx, idx_base, DUK_TYPE_MASK_UNDEFINED |
-+		                                     DUK_TYPE_MASK_OBJECT |
-+		                                     DUK_TYPE_MASK_LIGHTFUNC);
-+		get = duk_get_hobject_or_lfunc_coerce(ctx, idx_base);
-+		if (get != NULL && !DUK_HOBJECT_IS_CALLABLE(get)) {
-+			goto fail_not_callable;
-+		}
-+		idx_base--;
-+	} else {
-+		get = NULL;
-+	}
-+	if (flags & DUK_DEFPROP_HAVE_VALUE) {
-+		idx_value = idx_base;
-+		idx_base--;
-+	} else {
-+		idx_value = (duk_idx_t) -1;
-+	}
-+	key = duk_require_hstring(ctx, idx_base);
-+
-+	duk_require_valid_index(ctx, idx_base);
-+
-+	duk_hobject_define_property_helper(ctx,
-+	                                   flags /*defprop_flags*/,
-+	                                   obj,
-+	                                   key,
-+	                                   idx_value,
-+	                                   get,
-+	                                   set);
-+
-+	/* Clean up stack */
-+
-+	duk_set_top(ctx, idx_base);
-+
-+	/* [ ... obj ... ] */
-+
-+	return;
-+
-+ fail_invalid_desc:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_DESCRIPTOR);
-+	return;
-+
-+ fail_not_callable:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE);
-+	return;
-+}
-+
-+/*
-+ *  Object related
-+ *
-+ *  Note: seal() and freeze() are accessible through Ecmascript bindings,
-+ *  and are not exposed through the API.
-+ */
-+
-+DUK_EXTERNAL void duk_compact(duk_context *ctx, duk_idx_t obj_index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj = duk_get_hobject(ctx, obj_index);
-+	if (obj) {
-+		/* Note: this may fail, caller should protect the call if necessary */
-+		duk_hobject_compact_props(thr, obj);
-+	}
-+}
-+
-+/* XXX: the duk_hobject_enum.c stack APIs should be reworked */
-+
-+DUK_EXTERNAL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	duk_dup(ctx, obj_index);
-+	duk_require_hobject_or_lfunc_coerce(ctx, -1);
-+	duk_hobject_enumerator_create(ctx, enum_flags);   /* [target] -> [enum] */
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	duk_require_hobject(ctx, enum_index);
-+	duk_dup(ctx, enum_index);
-+	return duk_hobject_enumerator_next(ctx, get_value);
-+}
-+
-+/*
-+ *  Helpers for writing multiple properties
-+ */
-+
-+DUK_EXTERNAL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, const duk_function_list_entry *funcs) {
-+	const duk_function_list_entry *ent = funcs;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	if (ent != NULL) {
-+		while (ent->key != NULL) {
-+			duk_push_c_function(ctx, ent->value, ent->nargs);
-+			duk_put_prop_string(ctx, obj_index, ent->key);
-+			ent++;
-+		}
-+	}
-+}
-+
-+DUK_EXTERNAL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_index, const duk_number_list_entry *numbers) {
-+	const duk_number_list_entry *ent = numbers;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj_index = duk_require_normalize_index(ctx, obj_index);
-+	if (ent != NULL) {
-+		while (ent->key != NULL) {
-+			duk_push_number(ctx, ent->value);
-+			duk_put_prop_string(ctx, obj_index, ent->key);
-+			ent++;
-+		}
-+	}
-+}
-+
-+/*
-+ *  Shortcut for accessing global object properties
-+ */
-+
-+DUK_EXTERNAL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_bool_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL);
-+
-+	/* XXX: direct implementation */
-+
-+	duk_push_hobject(ctx, thr->builtins[DUK_BIDX_GLOBAL]);
-+	ret = duk_get_prop_string(ctx, -1, key);
-+	duk_remove(ctx, -2);
-+	return ret;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_bool_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL);
-+
-+	/* XXX: direct implementation */
-+
-+	duk_push_hobject(ctx, thr->builtins[DUK_BIDX_GLOBAL]);
-+	duk_insert(ctx, -2);
-+	ret = duk_put_prop_string(ctx, -2, key);  /* [ ... global val ] -> [ ... global ] */
-+	duk_pop(ctx);
-+	return ret;
-+}
-+
-+/*
-+ *  Object prototype
-+ */
-+
-+DUK_EXTERNAL void duk_get_prototype(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+	duk_hobject *proto;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_UNREF(thr);
-+
-+	obj = duk_require_hobject(ctx, index);
-+	DUK_ASSERT(obj != NULL);
-+
-+	/* XXX: shared helper for duk_push_hobject_or_undefined()? */
-+	proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, obj);
-+	if (proto) {
-+		duk_push_hobject(ctx, proto);
-+	} else {
-+		duk_push_undefined(ctx);
-+	}
-+}
-+
-+DUK_EXTERNAL void duk_set_prototype(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+	duk_hobject *proto;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj = duk_require_hobject(ctx, index);
-+	DUK_ASSERT(obj != NULL);
-+	duk_require_type_mask(ctx, -1, DUK_TYPE_MASK_UNDEFINED |
-+	                               DUK_TYPE_MASK_OBJECT);
-+	proto = duk_get_hobject(ctx, -1);
-+	/* proto can also be NULL here (allowed explicitly) */
-+
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, obj, proto);
-+
-+	duk_pop(ctx);
-+}
-+
-+/*
-+ *  Object finalizer
-+ */
-+
-+/* XXX: these could be implemented as macros calling an internal function
-+ * directly.
-+ * XXX: same issue as with Duktape.fin: there's no way to delete the property
-+ * now (just set it to undefined).
-+ */
-+DUK_EXTERNAL void duk_get_finalizer(duk_context *ctx, duk_idx_t index) {
-+	duk_get_prop_stridx(ctx, index, DUK_STRIDX_INT_FINALIZER);
-+}
-+
-+DUK_EXTERNAL void duk_set_finalizer(duk_context *ctx, duk_idx_t index) {
-+	duk_put_prop_stridx(ctx, index, DUK_STRIDX_INT_FINALIZER);
-+}
-+#line 1 "duk_api_stack.c"
-+/*
-+ *  API calls related to general value stack manipulation: resizing the value
-+ *  stack, pushing and popping values, type checking and reading values,
-+ *  coercing values, etc.
-+ *
-+ *  Also contains internal functions (such as duk_get_tval()), defined
-+ *  in duk_api_internal.h, with semantics similar to the public API.
-+ */
-+
-+/* XXX: repetition of stack pre-checks -> helper or macro or inline */
-+/* XXX: shared api error strings, and perhaps even throw code for rare cases? */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Forward declarations
-+ */
-+
-+DUK_LOCAL_DECL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_uint_t flags);
-+
-+/*
-+ *  Global state for working around missing variadic macros
-+ */
-+
-+#ifndef DUK_USE_VARIADIC_MACROS
-+DUK_EXTERNAL const char *duk_api_global_filename = NULL;
-+DUK_EXTERNAL duk_int_t duk_api_global_line = 0;
-+#endif
-+
-+/*
-+ *  Helpers
-+ */
-+
-+#if defined(DUK_USE_VALSTACK_UNSAFE)
-+/* Faster but value stack overruns are memory unsafe. */
-+#define  DUK__CHECK_SPACE() do { \
-+		DUK_ASSERT(!(thr->valstack_top >= thr->valstack_end)); \
-+	} while (0)
-+#else
-+#define  DUK__CHECK_SPACE() do { \
-+		if (thr->valstack_top >= thr->valstack_end) { \
-+			DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK); \
-+		} \
-+	} while (0)
-+#endif
-+
-+DUK_LOCAL duk_int_t duk__api_coerce_d2i(duk_context *ctx, duk_idx_t index, duk_bool_t require) {
-+	duk_hthread *thr;
-+	duk_tval *tv;
-+	duk_small_int_t c;
-+	duk_double_t d;
-+
-+	thr = (duk_hthread *) ctx;
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv == NULL) {
-+		goto error_notnumber;
-+	}
-+
-+	/*
-+	 *  Special cases like NaN and +/- Infinity are handled explicitly
-+	 *  because a plain C coercion from double to int handles these cases
-+	 *  in undesirable ways.  For instance, NaN may coerce to INT_MIN
-+	 *  (not zero), and INT_MAX + 1 may coerce to INT_MIN (not INT_MAX).
-+	 *
-+	 *  This double-to-int coercion differs from ToInteger() because it
-+	 *  has a finite range (ToInteger() allows e.g. +/- Infinity).  It
-+	 *  also differs from ToInt32() because the INT_MIN/INT_MAX clamping
-+	 *  depends on the size of the int type on the platform.  In particular,
-+	 *  on platforms with a 64-bit int type, the full range is allowed.
-+	 */
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv)) {
-+		duk_int64_t t = DUK_TVAL_GET_FASTINT(tv);
-+#if (DUK_INT_MAX <= 0x7fffffffL)
-+		/* Clamping only necessary for 32-bit ints. */
-+		if (t < DUK_INT_MIN) {
-+			t = DUK_INT_MIN;
-+		} else if (t > DUK_INT_MAX) {
-+			t = DUK_INT_MAX;
-+		}
-+#endif
-+		return (duk_int_t) t;
-+	}
-+#endif
-+
-+	if (DUK_TVAL_IS_NUMBER(tv)) {
-+		d = DUK_TVAL_GET_NUMBER(tv);
-+		c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-+		if (c == DUK_FP_NAN) {
-+			return 0;
-+		} else if (d < (duk_double_t) DUK_INT_MIN) {
-+			/* covers -Infinity */
-+			return DUK_INT_MIN;
-+		} else if (d > (duk_double_t) DUK_INT_MAX) {
-+			/* covers +Infinity */
-+			return DUK_INT_MAX;
-+		} else {
-+			/* coerce towards zero */
-+			return (duk_int_t) d;
-+		}
-+	}
-+
-+ error_notnumber:
-+
-+	if (require) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER);
-+	} else {
-+		return 0;
-+	}
-+}
-+
-+DUK_LOCAL duk_uint_t duk__api_coerce_d2ui(duk_context *ctx, duk_idx_t index, duk_bool_t require) {
-+	duk_hthread *thr;
-+	duk_tval *tv;
-+	duk_small_int_t c;
-+	duk_double_t d;
-+
-+	/* Same as above but for unsigned int range. */
-+
-+	thr = (duk_hthread *) ctx;
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv == NULL) {
-+		goto error_notnumber;
-+	}
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv)) {
-+		duk_int64_t t = DUK_TVAL_GET_FASTINT(tv);
-+		if (t < 0) {
-+			t = 0;
-+		}
-+#if (DUK_UINT_MAX <= 0xffffffffUL)
-+		/* Clamping only necessary for 32-bit ints. */
-+		else if (t > DUK_UINT_MAX) {
-+			t = DUK_UINT_MAX;
-+		}
-+#endif
-+		return (duk_uint_t) t;
-+	}
-+#endif
-+
-+	if (DUK_TVAL_IS_NUMBER(tv)) {
-+		d = DUK_TVAL_GET_NUMBER(tv);
-+		c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-+		if (c == DUK_FP_NAN) {
-+			return 0;
-+		} else if (d < 0.0) {
-+			/* covers -Infinity */
-+			return (duk_uint_t) 0;
-+		} else if (d > (duk_double_t) DUK_UINT_MAX) {
-+			/* covers +Infinity */
-+			return (duk_uint_t) DUK_UINT_MAX;
-+		} else {
-+			/* coerce towards zero */
-+			return (duk_uint_t) d;
-+		}
-+	}
-+
-+ error_notnumber:
-+
-+	if (require) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER);
-+	} else {
-+		return 0;
-+	}
-+}
-+
-+/*
-+ *  Stack index validation/normalization and getting a stack duk_tval ptr.
-+ *
-+ *  These are called by many API entrypoints so the implementations must be
-+ *  fast and "inlined".
-+ *
-+ *  There's some repetition because of this; keep the functions in sync.
-+ */
-+
-+DUK_EXTERNAL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t vs_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(DUK_INVALID_INDEX < 0);
-+
-+	/* Care must be taken to avoid pointer wrapping in the index
-+	 * validation.  For instance, on a 32-bit platform with 8-byte
-+	 * duk_tval the index 0x20000000UL would wrap the memory space
-+	 * once.
-+	 */
-+
-+	/* Assume value stack sizes (in elements) fits into duk_idx_t. */
-+	vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	DUK_ASSERT(vs_size >= 0);
-+
-+	if (index < 0) {
-+		index = vs_size + index;
-+		if (DUK_UNLIKELY(index < 0)) {
-+			/* Also catches index == DUK_INVALID_INDEX: vs_size >= 0
-+			 * so that vs_size + DUK_INVALID_INDEX cannot underflow
-+			 * and will always be negative.
-+			 */
-+			return DUK_INVALID_INDEX;
-+		}
-+	} else {
-+		/* since index non-negative */
-+		DUK_ASSERT(index != DUK_INVALID_INDEX);
-+
-+		if (DUK_UNLIKELY(index >= vs_size)) {
-+			return DUK_INVALID_INDEX;
-+		}
-+	}
-+
-+	DUK_ASSERT(index >= 0);
-+	DUK_ASSERT(index < vs_size);
-+	return index;
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t vs_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(DUK_INVALID_INDEX < 0);
-+
-+	vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	DUK_ASSERT(vs_size >= 0);
-+
-+	if (index < 0) {
-+		index = vs_size + index;
-+		if (DUK_UNLIKELY(index < 0)) {
-+			goto invalid_index;
-+		}
-+	} else {
-+		DUK_ASSERT(index != DUK_INVALID_INDEX);
-+		if (DUK_UNLIKELY(index >= vs_size)) {
-+			goto invalid_index;
-+		}
-+	}
-+
-+	DUK_ASSERT(index >= 0);
-+	DUK_ASSERT(index < vs_size);
-+	return index;
-+
-+ invalid_index:
-+	DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX);
-+	return 0;  /* unreachable */
-+}
-+
-+DUK_INTERNAL duk_tval *duk_get_tval(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t vs_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(DUK_INVALID_INDEX < 0);
-+
-+	vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	DUK_ASSERT(vs_size >= 0);
-+
-+	if (index < 0) {
-+		index = vs_size + index;
-+		if (DUK_UNLIKELY(index < 0)) {
-+			return NULL;
-+		}
-+	} else {
-+		DUK_ASSERT(index != DUK_INVALID_INDEX);
-+		if (DUK_UNLIKELY(index >= vs_size)) {
-+			return NULL;
-+		}
-+	}
-+
-+	DUK_ASSERT(index >= 0);
-+	DUK_ASSERT(index < vs_size);
-+	return thr->valstack_bottom + index;
-+}
-+
-+DUK_INTERNAL duk_tval *duk_require_tval(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t vs_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(DUK_INVALID_INDEX < 0);
-+
-+	vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	DUK_ASSERT(vs_size >= 0);
-+
-+	if (index < 0) {
-+		index = vs_size + index;
-+		if (DUK_UNLIKELY(index < 0)) {
-+			goto invalid_index;
-+		}
-+	} else {
-+		DUK_ASSERT(index != DUK_INVALID_INDEX);
-+		if (DUK_UNLIKELY(index >= vs_size)) {
-+			goto invalid_index;
-+		}
-+	}
-+
-+	DUK_ASSERT(index >= 0);
-+	DUK_ASSERT(index < vs_size);
-+	return thr->valstack_bottom + index;
-+
-+ invalid_index:
-+	DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX);
-+	return NULL;
-+}
-+
-+/* Non-critical. */
-+DUK_EXTERNAL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(DUK_INVALID_INDEX < 0);
-+	return (duk_normalize_index(ctx, index) >= 0);
-+}
-+
-+/* Non-critical. */
-+DUK_EXTERNAL void duk_require_valid_index(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(DUK_INVALID_INDEX < 0);
-+
-+	if (duk_normalize_index(ctx, index) < 0) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX);
-+	}
-+}
-+
-+/*
-+ *  Value stack top handling
-+ */
-+
-+DUK_EXTERNAL duk_idx_t duk_get_top(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	return (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+}
-+
-+/* set stack top within currently allocated range, but don't reallocate */
-+DUK_EXTERNAL void duk_set_top(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t vs_size;
-+	duk_idx_t vs_limit;
-+	duk_idx_t count;
-+	duk_tval tv_tmp;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(DUK_INVALID_INDEX < 0);
-+
-+	vs_size = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	vs_limit = (duk_idx_t) (thr->valstack_end - thr->valstack_bottom);
-+
-+	if (index < 0) {
-+		/* Negative indices are always within allocated stack but
-+		 * must not go below zero index.
-+		 */
-+		index = vs_size + index;
-+		if (index < 0) {
-+			/* Also catches index == DUK_INVALID_INDEX. */
-+			goto invalid_index;
-+		}
-+	} else {
-+		/* Positive index can be higher than valstack top but must
-+		 * not go above allocated stack (equality is OK).
-+		 */
-+		if (index > vs_limit) {
-+			goto invalid_index;
-+		}
-+	}
-+	DUK_ASSERT(index >= 0);
-+	DUK_ASSERT(index <= vs_limit);
-+
-+	if (index >= vs_size) {
-+		/* Stack size increases or stays the same.  Fill the new
-+		 * entries (if any) with undefined.  No pointer stability
-+		 * issues here so we can use a running pointer.
-+		 */
-+
-+		tv = thr->valstack_top;
-+		count = index - vs_size;
-+		DUK_ASSERT(count >= 0);
-+		while (count > 0) {
-+			/* no need to decref previous or new value */
-+			count--;
-+			DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv));
-+			DUK_TVAL_SET_UNDEFINED_ACTUAL(tv);
-+			tv++;
-+		}
-+		thr->valstack_top = tv;
-+	} else {
-+		/* Stack size decreases, DECREF entries which are above the
-+		 * new top.  Each DECREF potentially invalidates valstack
-+		 * pointers, so don't hold on to pointers.  The valstack top
-+		 * must also be updated on every loop in case a GC is triggered.
-+		 */
-+
-+		/* XXX: Here it would be useful to have a DECREF macro which
-+		 * doesn't need a NULL check, and does refzero queueing without
-+		 * running the refzero algorithm.  There would be no pointer
-+		 * instability in this case, and code could be inlined.  After
-+		 * the loop, one call to refzero would be needed.
-+		 */
-+
-+		count = vs_size - index;
-+		DUK_ASSERT(count > 0);
-+
-+		while (count > 0) {
-+			count--;
-+			tv = --thr->valstack_top;  /* tv -> value just before prev top value */
-+			DUK_ASSERT(tv >= thr->valstack_bottom);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+			DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+			/* XXX: fast primitive to set a bunch of values to UNDEFINED_UNUSED */
-+
-+		}
-+	}
-+	return;
-+
-+ invalid_index:
-+	DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX);
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_get_top_index(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
-+	if (DUK_UNLIKELY(ret < 0)) {
-+		/* Return invalid index; if caller uses this without checking
-+		 * in another API call, the index won't map to a valid stack
-+		 * entry.
-+		 */
-+		return DUK_INVALID_INDEX;
-+	}
-+	return ret;
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_require_top_index(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	ret = ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
-+	if (DUK_UNLIKELY(ret < 0)) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX);
-+	}
-+	return ret;
-+}
-+
-+/*
-+ *  Value stack resizing.
-+ *
-+ *  This resizing happens above the current "top": the value stack can be
-+ *  grown or shrunk, but the "top" is not affected.  The value stack cannot
-+ *  be resized to a size below the current "top".
-+ *
-+ *  The low level reallocation primitive must carefully recompute all value
-+ *  stack pointers, and must also work if ALL pointers are NULL.  The resize
-+ *  is quite tricky because the valstack realloc may cause a mark-and-sweep,
-+ *  which may run finalizers.  Running finalizers may resize the valstack
-+ *  recursively (the same value stack we're working on).  So, after realloc
-+ *  returns, we know that the valstack "top" should still be the same (there
-+ *  should not be live values above the "top"), but its underlying size and
-+ *  pointer may have changed.
-+ */
-+
-+/* XXX: perhaps refactor this to allow caller to specify some parameters, or
-+ * at least a 'compact' flag which skips any spare or round-up .. useful for
-+ * emergency gc.
-+ */
-+
-+DUK_LOCAL duk_bool_t duk__resize_valstack(duk_context *ctx, duk_size_t new_size) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_ptrdiff_t old_bottom_offset;
-+	duk_ptrdiff_t old_top_offset;
-+	duk_ptrdiff_t old_end_offset_post;
-+#ifdef DUK_USE_DEBUG
-+	duk_ptrdiff_t old_end_offset_pre;
-+	duk_tval *old_valstack_pre;
-+	duk_tval *old_valstack_post;
-+#endif
-+	duk_tval *new_valstack;
-+	duk_tval *p;
-+	duk_size_t new_alloc_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+	DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) <= new_size);  /* can't resize below 'top' */
-+	DUK_ASSERT(new_size <= thr->valstack_max);  /* valstack limit caller has check, prevents wrapping */
-+	DUK_ASSERT(new_size <= DUK_SIZE_MAX / sizeof(duk_tval));  /* specific assert for wrapping */
-+
-+	/* get pointer offsets for tweaking below */
-+	old_bottom_offset = (((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack));
-+	old_top_offset = (((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack));
-+#ifdef DUK_USE_DEBUG
-+	old_end_offset_pre = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack));  /* not very useful, used for debugging */
-+	old_valstack_pre = thr->valstack;
-+#endif
-+
-+	/* Allocate a new valstack.
-+	 *
-+	 * Note: cannot use a plain DUK_REALLOC() because a mark-and-sweep may
-+	 * invalidate the original thr->valstack base pointer inside the realloc
-+	 * process.  See doc/memory-management.txt.
-+	 */
-+
-+	new_alloc_size = sizeof(duk_tval) * new_size;
-+	new_valstack = (duk_tval *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_valstack_ptr, (void *) thr, new_alloc_size);
-+	if (!new_valstack) {
-+		/* Because new_size != 0, if condition doesn't need to be
-+		 * (new_valstack != NULL || new_size == 0).
-+		 */
-+		DUK_ASSERT(new_size != 0);
-+		DUK_D(DUK_DPRINT("failed to resize valstack to %lu entries (%lu bytes)",
-+		                 (unsigned long) new_size, (unsigned long) new_alloc_size));
-+		return 0;
-+	}
-+
-+	/* Note: the realloc may have triggered a mark-and-sweep which may
-+	 * have resized our valstack internally.  However, the mark-and-sweep
-+	 * MUST NOT leave the stack bottom/top in a different state.  Particular
-+	 * assumptions and facts:
-+	 *
-+	 *   - The thr->valstack pointer may be different after realloc,
-+	 *     and the offset between thr->valstack_end <-> thr->valstack
-+	 *     may have changed.
-+	 *   - The offset between thr->valstack_bottom <-> thr->valstack
-+	 *     and thr->valstack_top <-> thr->valstack MUST NOT have changed,
-+	 *     because mark-and-sweep must adhere to a strict stack policy.
-+	 *     In other words, logical bottom and top MUST NOT have changed.
-+	 *   - All values above the top are unreachable but are initialized
-+	 *     to UNDEFINED_UNUSED, up to the post-realloc valstack_end.
-+	 *   - 'old_end_offset' must be computed after realloc to be correct.
-+	 */
-+
-+	DUK_ASSERT((((duk_uint8_t *) thr->valstack_bottom) - ((duk_uint8_t *) thr->valstack)) == old_bottom_offset);
-+	DUK_ASSERT((((duk_uint8_t *) thr->valstack_top) - ((duk_uint8_t *) thr->valstack)) == old_top_offset);
-+
-+	/* success, fixup pointers */
-+	old_end_offset_post = (((duk_uint8_t *) thr->valstack_end) - ((duk_uint8_t *) thr->valstack));  /* must be computed after realloc */
-+#ifdef DUK_USE_DEBUG
-+	old_valstack_post = thr->valstack;
-+#endif
-+	thr->valstack = new_valstack;
-+	thr->valstack_end = new_valstack + new_size;
-+	thr->valstack_bottom = (duk_tval *) ((duk_uint8_t *) new_valstack + old_bottom_offset);
-+	thr->valstack_top = (duk_tval *) ((duk_uint8_t *) new_valstack + old_top_offset);
-+
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+
-+	/* useful for debugging */
-+#ifdef DUK_USE_DEBUG
-+	if (old_end_offset_pre != old_end_offset_post) {
-+		DUK_D(DUK_DPRINT("valstack was resized during valstack_resize(), probably by mark-and-sweep; "
-+		                 "end offset changed: %lu -> %lu",
-+		                 (unsigned long) old_end_offset_pre,
-+		                 (unsigned long) old_end_offset_post));
-+	}
-+	if (old_valstack_pre != old_valstack_post) {
-+		DUK_D(DUK_DPRINT("valstack pointer changed during valstack_resize(), probably by mark-and-sweep: %p -> %p",
-+		                 (void *) old_valstack_pre,
-+		                 (void *) old_valstack_post));
-+	}
-+#endif
-+
-+	DUK_DD(DUK_DDPRINT("resized valstack to %lu elements (%lu bytes), bottom=%ld, top=%ld, "
-+	                   "new pointers: start=%p end=%p bottom=%p top=%p",
-+	                   (unsigned long) new_size, (unsigned long) new_alloc_size,
-+	                   (long) (thr->valstack_bottom - thr->valstack),
-+	                   (long) (thr->valstack_top - thr->valstack),
-+	                   (void *) thr->valstack, (void *) thr->valstack_end,
-+	                   (void *) thr->valstack_bottom, (void *) thr->valstack_top));
-+
-+	/* init newly allocated slots (only) */
-+	p = (duk_tval *) ((duk_uint8_t *) thr->valstack + old_end_offset_post);
-+	while (p < thr->valstack_end) {
-+		/* never executed if new size is smaller */
-+		DUK_TVAL_SET_UNDEFINED_UNUSED(p);
-+		p++;
-+	}
-+
-+	/* assertion check: we maintain elements above top in known state */
-+#ifdef DUK_USE_ASSERTIONS
-+	p = thr->valstack_top;
-+	while (p < thr->valstack_end) {
-+		/* everything above old valstack top should be preinitialized now */
-+		DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(p));
-+		p++;
-+	}
-+#endif
-+	return 1;
-+}
-+
-+DUK_INTERNAL
-+duk_bool_t duk_valstack_resize_raw(duk_context *ctx,
-+                                   duk_size_t min_new_size,
-+                                   duk_small_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_size_t old_size;
-+	duk_size_t new_size;
-+	duk_bool_t is_shrink = 0;
-+	duk_small_uint_t shrink_flag = (flags & DUK_VSRESIZE_FLAG_SHRINK);
-+	duk_small_uint_t compact_flag = (flags & DUK_VSRESIZE_FLAG_COMPACT);
-+	duk_small_uint_t throw_flag = (flags & DUK_VSRESIZE_FLAG_THROW);
-+
-+	DUK_DDD(DUK_DDDPRINT("check valstack resize: min_new_size=%lu, curr_size=%ld, curr_top=%ld, "
-+	                     "curr_bottom=%ld, shrink=%d, compact=%d, throw=%d",
-+	                     (unsigned long) min_new_size,
-+	                     (long) (thr->valstack_end - thr->valstack),
-+	                     (long) (thr->valstack_top - thr->valstack),
-+	                     (long) (thr->valstack_bottom - thr->valstack),
-+	                     (int) shrink_flag, (int) compact_flag, (int) throw_flag));
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+
-+	old_size = (duk_size_t) (thr->valstack_end - thr->valstack);
-+
-+	if (min_new_size <= old_size) {
-+		is_shrink = 1;
-+		if (!shrink_flag ||
-+		    old_size - min_new_size < DUK_VALSTACK_SHRINK_THRESHOLD) {
-+			DUK_DDD(DUK_DDDPRINT("no need to grow or shrink valstack"));
-+			return 1;
-+		}
-+	}
-+
-+	new_size = min_new_size;
-+	if (!compact_flag) {
-+		if (is_shrink) {
-+			/* shrink case; leave some spare */
-+			new_size += DUK_VALSTACK_SHRINK_SPARE;
-+		}
-+
-+		/* round up roughly to next 'grow step' */
-+		new_size = (new_size / DUK_VALSTACK_GROW_STEP + 1) * DUK_VALSTACK_GROW_STEP;
-+	}
-+
-+	DUK_DD(DUK_DDPRINT("want to %s valstack: %lu -> %lu elements (min_new_size %lu)",
-+	                   (const char *) (new_size > old_size ? "grow" : "shrink"),
-+	                   (unsigned long) old_size, (unsigned long) new_size,
-+	                   (unsigned long) min_new_size));
-+
-+	if (new_size > thr->valstack_max) {
-+		/* Note: may be triggered even if minimal new_size would not reach the limit,
-+		 * plan limit accordingly (taking DUK_VALSTACK_GROW_STEP into account).
-+		 */
-+		if (throw_flag) {
-+			DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_VALSTACK_LIMIT);
-+		} else {
-+			return 0;
-+		}
-+	}
-+
-+	/*
-+	 *  When resizing the valstack, a mark-and-sweep may be triggered for
-+	 *  the allocation of the new valstack.  If the mark-and-sweep needs
-+	 *  to use our thread for something, it may cause *the same valstack*
-+	 *  to be resized recursively.  This happens e.g. when mark-and-sweep
-+	 *  finalizers are called.  This is taken into account carefully in
-+	 *  duk__resize_valstack().
-+	 *
-+	 *  'new_size' is known to be <= valstack_max, which ensures that
-+	 *  size_t and pointer arithmetic won't wrap in duk__resize_valstack().
-+	 */
-+
-+	if (!duk__resize_valstack(ctx, new_size)) {
-+		if (is_shrink) {
-+			DUK_DD(DUK_DDPRINT("valstack resize failed, but is a shrink, ignore"));
-+			return 1;
-+		}
-+
-+		DUK_DD(DUK_DDPRINT("valstack resize failed"));
-+
-+		if (throw_flag) {
-+			DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_FAILED_TO_EXTEND_VALSTACK);
-+		} else {
-+			return 0;
-+		}
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("valstack resize successful"));
-+	return 1;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_size_t min_new_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+
-+	if (DUK_UNLIKELY(extra < 0)) {
-+		/* Clamping to zero makes the API more robust to calling code
-+		 * calculation errors.
-+		 */
-+		extra = 0;
-+	}
-+
-+	min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA;
-+	return duk_valstack_resize_raw(ctx,
-+	                               min_new_size,         /* min_new_size */
-+	                               0 /* no shrink */ |   /* flags */
-+	                               0 /* no compact */ |
-+	                               0 /* no throw */);
-+}
-+
-+DUK_EXTERNAL void duk_require_stack(duk_context *ctx, duk_idx_t extra) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_size_t min_new_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+
-+	if (DUK_UNLIKELY(extra < 0)) {
-+		/* Clamping to zero makes the API more robust to calling code
-+		 * calculation errors.
-+		 */
-+		extra = 0;
-+	}
-+
-+	min_new_size = (thr->valstack_top - thr->valstack) + extra + DUK_VALSTACK_INTERNAL_EXTRA;
-+	(void) duk_valstack_resize_raw(ctx,
-+	                               min_new_size,  /* min_new_size */
-+	                               0 /* no shrink */ |   /* flags */
-+	                               0 /* no compact */ |
-+	                               DUK_VSRESIZE_FLAG_THROW);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top) {
-+	duk_size_t min_new_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	if (DUK_UNLIKELY(top < 0)) {
-+		/* Clamping to zero makes the API more robust to calling code
-+		 * calculation errors.
-+		 */
-+		top = 0;
-+	}
-+
-+	min_new_size = top + DUK_VALSTACK_INTERNAL_EXTRA;
-+	return duk_valstack_resize_raw(ctx,
-+	                               min_new_size,  /* min_new_size */
-+	                               0 /* no shrink */ |   /* flags */
-+	                               0 /* no compact */ |
-+	                               0 /* no throw */);
-+}
-+
-+DUK_EXTERNAL void duk_require_stack_top(duk_context *ctx, duk_idx_t top) {
-+	duk_size_t min_new_size;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	if (DUK_UNLIKELY(top < 0)) {
-+		/* Clamping to zero makes the API more robust to calling code
-+		 * calculation errors.
-+		 */
-+		top = 0;
-+	}
-+
-+	min_new_size = top + DUK_VALSTACK_INTERNAL_EXTRA;
-+	(void) duk_valstack_resize_raw(ctx,
-+	                               min_new_size,  /* min_new_size */
-+	                               0 /* no shrink */ |   /* flags */
-+	                               0 /* no compact */ |
-+	                               DUK_VSRESIZE_FLAG_THROW);
-+}
-+
-+/*
-+ *  Basic stack manipulation: swap, dup, insert, replace, etc
-+ */
-+
-+DUK_EXTERNAL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) {
-+	duk_tval *tv1;
-+	duk_tval *tv2;
-+	duk_tval tv_tmp;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv1 = duk_require_tval(ctx, index1);
-+	DUK_ASSERT(tv1 != NULL);
-+	tv2 = duk_require_tval(ctx, index2);
-+	DUK_ASSERT(tv2 != NULL);
-+
-+	/* If tv1==tv2 this is a NOP, no check is needed */
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+	DUK_TVAL_SET_TVAL(tv1, tv2);
-+	DUK_TVAL_SET_TVAL(tv2, &tv_tmp);
-+}
-+
-+DUK_EXTERNAL void duk_swap_top(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	duk_swap(ctx, index, -1);
-+}
-+
-+DUK_EXTERNAL void duk_dup(duk_context *ctx, duk_idx_t from_index) {
-+	duk_hthread *thr;
-+	duk_tval *tv_from;
-+	duk_tval *tv_to;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+
-+	tv_from = duk_require_tval(ctx, from_index);
-+	tv_to = thr->valstack_top++;
-+	DUK_ASSERT(tv_from != NULL);
-+	DUK_ASSERT(tv_to != NULL);
-+	DUK_TVAL_SET_TVAL(tv_to, tv_from);
-+	DUK_TVAL_INCREF(thr, tv_to);  /* no side effects */
-+}
-+
-+DUK_EXTERNAL void duk_dup_top(duk_context *ctx) {
-+	duk_hthread *thr;
-+	duk_tval *tv_from;
-+	duk_tval *tv_to;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+
-+	if (thr->valstack_top - thr->valstack_bottom <= 0) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_INDEX);
-+	}
-+	tv_from = thr->valstack_top - 1;
-+	tv_to = thr->valstack_top++;
-+	DUK_ASSERT(tv_from != NULL);
-+	DUK_ASSERT(tv_to != NULL);
-+	DUK_TVAL_SET_TVAL(tv_to, tv_from);
-+	DUK_TVAL_INCREF(thr, tv_to);  /* no side effects */
-+}
-+
-+DUK_EXTERNAL void duk_insert(duk_context *ctx, duk_idx_t to_index) {
-+	duk_tval *p;
-+	duk_tval *q;
-+	duk_tval tv_tmp;
-+	duk_size_t nbytes;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	p = duk_require_tval(ctx, to_index);
-+	DUK_ASSERT(p != NULL);
-+	q = duk_require_tval(ctx, -1);
-+	DUK_ASSERT(q != NULL);
-+
-+	DUK_ASSERT(q >= p);
-+
-+	/*              nbytes
-+	 *           <--------->
-+	 *    [ ... | p | x | x | q ]
-+	 * => [ ... | q | p | x | x ]
-+	 */
-+
-+	nbytes = (duk_size_t) (((duk_uint8_t *) q) - ((duk_uint8_t *) p));  /* Note: 'q' is top-1 */
-+
-+	DUK_DDD(DUK_DDDPRINT("duk_insert: to_index=%ld, p=%p, q=%p, nbytes=%lu",
-+	                     (long) to_index, (void *) p, (void *) q, (unsigned long) nbytes));
-+
-+	/* No net refcount changes. */
-+
-+	if (nbytes > 0) {
-+		DUK_TVAL_SET_TVAL(&tv_tmp, q);
-+		DUK_ASSERT(nbytes > 0);
-+		DUK_MEMMOVE((void *) (p + 1), (void *) p, nbytes);
-+		DUK_TVAL_SET_TVAL(p, &tv_tmp);
-+	} else {
-+		/* nop: insert top to top */
-+		DUK_ASSERT(nbytes == 0);
-+		DUK_ASSERT(p == q);
-+	}
-+}
-+
-+DUK_EXTERNAL void duk_replace(duk_context *ctx, duk_idx_t to_index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv1;
-+	duk_tval *tv2;
-+	duk_tval tv_tmp;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv1 = duk_require_tval(ctx, -1);
-+	DUK_ASSERT(tv1 != NULL);
-+	tv2 = duk_require_tval(ctx, to_index);
-+	DUK_ASSERT(tv2 != NULL);
-+
-+	/* For tv1 == tv2, both pointing to stack top, the end result
-+	 * is same as duk_pop(ctx).
-+	 */
-+
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv2);
-+	DUK_TVAL_SET_TVAL(tv2, tv1);
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(tv1);
-+	thr->valstack_top--;
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+}
-+
-+DUK_EXTERNAL void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv1;
-+	duk_tval *tv2;
-+	duk_tval tv_tmp;
-+
-+	DUK_UNREF(thr);  /* w/o refcounting */
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv1 = duk_require_tval(ctx, from_index);
-+	DUK_ASSERT(tv1 != NULL);
-+	tv2 = duk_require_tval(ctx, to_index);
-+	DUK_ASSERT(tv2 != NULL);
-+
-+	/* For tv1 == tv2, this is a no-op (no explicit check needed). */
-+
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv2);
-+	DUK_TVAL_SET_TVAL(tv2, tv1);
-+	DUK_TVAL_INCREF(thr, tv2);  /* no side effects */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+}
-+
-+DUK_EXTERNAL void duk_remove(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *p;
-+	duk_tval *q;
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk_tval tv_tmp;
-+#endif
-+	duk_size_t nbytes;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	p = duk_require_tval(ctx, index);
-+	DUK_ASSERT(p != NULL);
-+	q = duk_require_tval(ctx, -1);
-+	DUK_ASSERT(q != NULL);
-+
-+	DUK_ASSERT(q >= p);
-+
-+	/*              nbytes            zero size case
-+	 *           <--------->
-+	 *    [ ... | p | x | x | q ]     [ ... | p==q ]
-+	 * => [ ... | x | x | q ]         [ ... ]
-+	 */
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	/* use a temp: decref only when valstack reachable values are correct */
-+	DUK_TVAL_SET_TVAL(&tv_tmp, p);
-+#endif
-+
-+	nbytes = (duk_size_t) (((duk_uint8_t *) q) - ((duk_uint8_t *) p));  /* Note: 'q' is top-1 */
-+	DUK_MEMMOVE(p, p + 1, nbytes);  /* zero size not an issue: pointers are valid */
-+
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(q);
-+	thr->valstack_top--;
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+#endif
-+}
-+
-+/*
-+ *  Stack slice primitives
-+ */
-+
-+DUK_EXTERNAL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy) {
-+	duk_hthread *to_thr = (duk_hthread *) to_ctx;
-+	duk_hthread *from_thr = (duk_hthread *) from_ctx;
-+	void *src;
-+	duk_size_t nbytes;
-+	duk_tval *p;
-+	duk_tval *q;
-+
-+	/* XXX: several pointer comparison issues here */
-+
-+	DUK_ASSERT(to_ctx != NULL);
-+	DUK_ASSERT(from_ctx != NULL);
-+
-+	if (to_ctx == from_ctx) {
-+		DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CONTEXT);
-+		return;
-+	}
-+	if ((count < 0) ||
-+	    (count > (duk_idx_t) to_thr->valstack_max)) {
-+		/* Maximum value check ensures 'nbytes' won't wrap below. */
-+		DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT);
-+		return;
-+	}
-+
-+	nbytes = sizeof(duk_tval) * count;
-+	if (nbytes == 0) {
-+		return;
-+	}
-+	DUK_ASSERT(to_thr->valstack_top <= to_thr->valstack_end);
-+	if ((duk_size_t) ((duk_uint8_t *) to_thr->valstack_end - (duk_uint8_t *) to_thr->valstack_top) < nbytes) {
-+		DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
-+	}
-+	src = (void *) ((duk_uint8_t *) from_thr->valstack_top - nbytes);
-+	if (src < (void *) from_thr->valstack_bottom) {
-+		DUK_ERROR(to_thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT);
-+	}
-+
-+	/* copy values (no overlap even if to_ctx == from_ctx; that's not
-+	 * allowed now anyway)
-+	 */
-+	DUK_ASSERT(nbytes > 0);
-+	DUK_MEMCPY((void *) to_thr->valstack_top, src, nbytes);
-+
-+	p = to_thr->valstack_top;
-+	to_thr->valstack_top = (duk_tval *) (((duk_uint8_t *) p) + nbytes);
-+
-+	if (is_copy) {
-+		/* incref copies, keep originals */
-+		q = to_thr->valstack_top;
-+		while (p < q) {
-+			DUK_TVAL_INCREF(to_thr, p);  /* no side effects */
-+			p++;
-+		}
-+	} else {
-+		/* no net refcount change */
-+		p = from_thr->valstack_top;
-+		q = (duk_tval *) (((duk_uint8_t *) p) - nbytes);
-+		from_thr->valstack_top = q;
-+
-+		/* elements above stack top are kept UNUSED */
-+		while (p > q) {
-+			p--;
-+			DUK_TVAL_SET_UNDEFINED_UNUSED(p);
-+
-+			/* XXX: fast primitive to set a bunch of values to UNDEFINED_UNUSED */
-+		}
-+	}
-+}
-+
-+/*
-+ *  Get/require
-+ */
-+
-+DUK_EXTERNAL void duk_require_undefined(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_UNDEFINED(tv)) {
-+		/* Note: accept both 'actual' and 'unused' undefined */
-+		return;
-+	}
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_UNDEFINED);
-+}
-+
-+DUK_EXTERNAL void duk_require_null(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_NULL(tv)) {
-+		return;
-+	}
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NULL);
-+	return;  /* not reachable */
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index) {
-+	duk_bool_t ret = 0;  /* default: false */
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_BOOLEAN(tv)) {
-+		ret = DUK_TVAL_GET_BOOLEAN(tv);
-+	}
-+
-+	DUK_ASSERT(ret == 0 || ret == 1);
-+	return ret;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_BOOLEAN(tv)) {
-+		duk_bool_t ret = DUK_TVAL_GET_BOOLEAN(tv);
-+		DUK_ASSERT(ret == 0 || ret == 1);
-+		return ret;
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BOOLEAN);
-+	return 0;  /* not reachable */
-+}
-+
-+DUK_EXTERNAL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index) {
-+	duk_double_union ret;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	ret.d = DUK_DOUBLE_NAN;  /* default: NaN */
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_NUMBER(tv)) {
-+		ret.d = DUK_TVAL_GET_NUMBER(tv);
-+	}
-+
-+	/*
-+	 *  Number should already be in NaN-normalized form, but let's
-+	 *  normalize anyway.
-+	 */
-+
-+	DUK_DBLUNION_NORMALIZE_NAN_CHECK(&ret);
-+	return ret.d;
-+}
-+
-+DUK_EXTERNAL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_NUMBER(tv)) {
-+		duk_double_union ret;
-+		ret.d = DUK_TVAL_GET_NUMBER(tv);
-+
-+		/*
-+		 *  Number should already be in NaN-normalized form,
-+		 *  but let's normalize anyway.
-+		 */
-+
-+		DUK_DBLUNION_NORMALIZE_NAN_CHECK(&ret);
-+		return ret.d;
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NUMBER);
-+	return DUK_DOUBLE_NAN;  /* not reachable */
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index) {
-+	/* Custom coercion for API */
-+	return (duk_int_t) duk__api_coerce_d2i(ctx, index, 0 /*require*/);
-+}
-+
-+DUK_EXTERNAL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index) {
-+	/* Custom coercion for API */
-+	return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/);
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index) {
-+	/* Custom coercion for API */
-+	return (duk_int_t) duk__api_coerce_d2i(ctx, index, 1 /*require*/);
-+}
-+
-+DUK_EXTERNAL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index) {
-+	/* Custom coercion for API */
-+	return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 1 /*require*/);
-+}
-+
-+DUK_EXTERNAL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
-+	const char *ret;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* default: NULL, length 0 */
-+	ret = NULL;
-+	if (out_len) {
-+		*out_len = 0;
-+	}
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_STRING(tv)) {
-+		/* Here we rely on duk_hstring instances always being zero
-+		 * terminated even if the actual string is not.
-+		 */
-+		duk_hstring *h = DUK_TVAL_GET_STRING(tv);
-+		DUK_ASSERT(h != NULL);
-+		ret = (const char *) DUK_HSTRING_GET_DATA(h);
-+		if (out_len) {
-+			*out_len = DUK_HSTRING_GET_BYTELEN(h);
-+		}
-+	}
-+
-+	return ret;
-+}
-+
-+DUK_EXTERNAL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	const char *ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* Note: this check relies on the fact that even a zero-size string
-+	 * has a non-NULL pointer.
-+	 */
-+	ret = duk_get_lstring(ctx, index, out_len);
-+	if (ret) {
-+		return ret;
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_STRING);
-+	return NULL;  /* not reachable */
-+}
-+
-+DUK_EXTERNAL const char *duk_get_string(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	return duk_get_lstring(ctx, index, NULL);
-+}
-+
-+DUK_EXTERNAL const char *duk_require_string(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	return duk_require_lstring(ctx, index, NULL);
-+}
-+
-+DUK_EXTERNAL void *duk_get_pointer(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_POINTER(tv)) {
-+		void *p = DUK_TVAL_GET_POINTER(tv);  /* may be NULL */
-+		return (void *) p;
-+	}
-+
-+	return NULL;
-+}
-+
-+DUK_EXTERNAL void *duk_require_pointer(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* Note: here we must be wary of the fact that a pointer may be
-+	 * valid and be a NULL.
-+	 */
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_POINTER(tv)) {
-+		void *p = DUK_TVAL_GET_POINTER(tv);  /* may be NULL */
-+		return (void *) p;
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_POINTER);
-+	return NULL;  /* not reachable */
-+}
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL void *duk_get_voidptr(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
-+		DUK_ASSERT(h != NULL);
-+		return (void *) h;
-+	}
-+
-+	return NULL;
-+}
-+#endif
-+
-+DUK_EXTERNAL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_UNREF(thr);
-+
-+	if (out_size != NULL) {
-+		*out_size = 0;
-+	}
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_BUFFER(tv)) {
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
-+		DUK_ASSERT(h != NULL);
-+		if (out_size) {
-+			*out_size = DUK_HBUFFER_GET_SIZE(h);
-+		}
-+		return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);  /* may be NULL (but only if size is 0) */
-+	}
-+
-+	return NULL;
-+}
-+
-+DUK_EXTERNAL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	if (out_size != NULL) {
-+		*out_size = 0;
-+	}
-+
-+	/* Note: here we must be wary of the fact that a data pointer may
-+	 * be a NULL for a zero-size buffer.
-+	 */
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_BUFFER(tv)) {
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
-+		DUK_ASSERT(h != NULL);
-+		if (out_size) {
-+			*out_size = DUK_HBUFFER_GET_SIZE(h);
-+		}
-+		return (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);  /* may be NULL (but only if size is 0) */
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_BUFFER);
-+	return NULL;  /* not reachable */
-+}
-+
-+/* Raw helper for getting a value from the stack, checking its tag, and possible its object class.
-+ * The tag cannot be a number because numbers don't have an internal tag in the packed representation.
-+ */
-+DUK_INTERNAL duk_heaphdr *duk_get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t flags_and_tag) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_small_uint_t tag = flags_and_tag & 0xffffU;  /* tags can be up to 16 bits */
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && (DUK_TVAL_GET_TAG(tv) == tag)) {
-+		duk_heaphdr *ret;
-+
-+		/* Note: tag comparison in general doesn't work for numbers,
-+		 * but it does work for everything else (heap objects here).
-+		 */
-+		ret = DUK_TVAL_GET_HEAPHDR(tv);
-+		DUK_ASSERT(ret != NULL);  /* tagged null pointers should never occur */
-+
-+		/* If class check has been requested, tag must also be DUK_TAG_OBJECT.
-+		 * This allows us to just check the class check flag without checking
-+		 * the tag also.
-+		 */
-+		DUK_ASSERT((flags_and_tag & DUK_GETTAGGED_FLAG_CHECK_CLASS) == 0 ||
-+		           tag == DUK_TAG_OBJECT);
-+
-+		if ((flags_and_tag & DUK_GETTAGGED_FLAG_CHECK_CLASS) == 0 ||  /* no class check */
-+		    (duk_int_t) DUK_HOBJECT_GET_CLASS_NUMBER((duk_hobject *) ret) ==  /* or class check matches */
-+		        (duk_int_t) ((flags_and_tag >> DUK_GETTAGGED_CLASS_SHIFT) & 0xff)) {
-+			return ret;
-+		}
-+	}
-+
-+	if (flags_and_tag & DUK_GETTAGGED_FLAG_ALLOW_NULL) {
-+		return (duk_heaphdr *) NULL;
-+	}
-+
-+	/* Formatting the tag number here is not very useful: the tag value
-+	 * is Duktape internal (not the same as DUK_TYPE_xxx) and even depends
-+	 * on the duk_tval layout.  If anything, add a human readable type here.
-+	 */
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE);
-+	return NULL;  /* not reachable */
-+}
-+
-+DUK_INTERNAL duk_hstring *duk_get_hstring(duk_context *ctx, duk_idx_t index) {
-+	return (duk_hstring *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING | DUK_GETTAGGED_FLAG_ALLOW_NULL);
-+}
-+
-+DUK_INTERNAL duk_hstring *duk_require_hstring(duk_context *ctx, duk_idx_t index) {
-+	return (duk_hstring *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_STRING);
-+}
-+
-+DUK_INTERNAL duk_hobject *duk_get_hobject(duk_context *ctx, duk_idx_t index) {
-+	return (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL);
-+}
-+
-+DUK_INTERNAL duk_hobject *duk_require_hobject(duk_context *ctx, duk_idx_t index) {
-+	return (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
-+}
-+
-+DUK_INTERNAL duk_hbuffer *duk_get_hbuffer(duk_context *ctx, duk_idx_t index) {
-+	return (duk_hbuffer *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER | DUK_GETTAGGED_FLAG_ALLOW_NULL);
-+}
-+
-+DUK_INTERNAL duk_hbuffer *duk_require_hbuffer(duk_context *ctx, duk_idx_t index) {
-+	return (duk_hbuffer *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_BUFFER);
-+}
-+
-+DUK_INTERNAL duk_hthread *duk_get_hthread(duk_context *ctx, duk_idx_t index) {
-+	duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL);
-+	if (h != NULL && !DUK_HOBJECT_IS_THREAD(h)) {
-+		h = NULL;
-+	}
-+	return (duk_hthread *) h;
-+}
-+
-+DUK_INTERNAL duk_hthread *duk_require_hthread(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
-+	DUK_ASSERT(h != NULL);
-+	if (!DUK_HOBJECT_IS_THREAD(h)) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_THREAD);
-+	}
-+	return (duk_hthread *) h;
-+}
-+
-+DUK_INTERNAL duk_hcompiledfunction *duk_get_hcompiledfunction(duk_context *ctx, duk_idx_t index) {
-+	duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL);
-+	if (h != NULL && !DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
-+		h = NULL;
-+	}
-+	return (duk_hcompiledfunction *) h;
-+}
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL duk_hcompiledfunction *duk_require_hcompiledfunction(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
-+	DUK_ASSERT(h != NULL);
-+	if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_COMPILEDFUNCTION);
-+	}
-+	return (duk_hcompiledfunction *) h;
-+}
-+#endif
-+
-+DUK_INTERNAL duk_hnativefunction *duk_get_hnativefunction(duk_context *ctx, duk_idx_t index) {
-+	duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL);
-+	if (h != NULL && !DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
-+		h = NULL;
-+	}
-+	return (duk_hnativefunction *) h;
-+}
-+
-+DUK_INTERNAL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h = (duk_hobject *) duk_get_tagged_heaphdr_raw(ctx, index, DUK_TAG_OBJECT);
-+	DUK_ASSERT(h != NULL);
-+	if (!DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_NATIVEFUNCTION);
-+	}
-+	return (duk_hnativefunction *) h;
-+}
-+
-+DUK_EXTERNAL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+	duk_hobject *h;
-+	duk_hnativefunction *f;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (!tv) {
-+		return NULL;
-+	}
-+	if (!DUK_TVAL_IS_OBJECT(tv)) {
-+		return NULL;
-+	}
-+	h = DUK_TVAL_GET_OBJECT(tv);
-+	DUK_ASSERT(h != NULL);
-+
-+	if (!DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
-+		return NULL;
-+	}
-+	DUK_ASSERT(DUK_HOBJECT_HAS_NATIVEFUNCTION(h));
-+	f = (duk_hnativefunction *) h;
-+
-+	return f->func;
-+}
-+
-+DUK_EXTERNAL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_c_function ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	ret = duk_get_c_function(ctx, index);
-+	if (!ret) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_C_FUNCTION);
-+	}
-+	return ret;
-+}
-+
-+DUK_EXTERNAL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index) {
-+	return (duk_context *) duk_get_hthread(ctx, index);
-+}
-+
-+DUK_EXTERNAL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index) {
-+	return (duk_context *) duk_require_hthread(ctx, index);
-+}
-+
-+DUK_EXTERNAL void *duk_get_heapptr(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+	void *ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		ret = (void *) DUK_TVAL_GET_HEAPHDR(tv);
-+		DUK_ASSERT(ret != NULL);
-+		return ret;
-+	}
-+
-+	return (void *) NULL;
-+}
-+
-+DUK_EXTERNAL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	void *ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		ret = (void *) DUK_TVAL_GET_HEAPHDR(tv);
-+		DUK_ASSERT(ret != NULL);
-+		return ret;
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE);
-+	return (void *) NULL;  /* not reachable */
-+}
-+
-+#if 0
-+/* This would be pointless: we'd return NULL for both lightfuncs and
-+ * unexpected types.
-+ */
-+duk_hobject *duk_get_hobject_or_lfunc(duk_context *ctx, duk_idx_t index) {
-+}
-+#endif
-+
-+/* Useful for internal call sites where we either expect an object (function)
-+ * or a lightfunc.  Accepts an object (returned as is) or a lightfunc (coerced
-+ * to an object).  Return value is NULL if value is neither an object nor a
-+ * lightfunc.
-+ */
-+duk_hobject *duk_get_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	if (DUK_TVAL_IS_OBJECT(tv)) {
-+		return DUK_TVAL_GET_OBJECT(tv);
-+	} else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
-+		duk_to_object(ctx, index);
-+		return duk_require_hobject(ctx, index);
-+	}
-+
-+	return NULL;
-+}
-+
-+/* Useful for internal call sites where we either expect an object (function)
-+ * or a lightfunc.  Returns NULL for a lightfunc.
-+ */
-+DUK_INTERNAL duk_hobject *duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	if (DUK_TVAL_IS_OBJECT(tv)) {
-+		return DUK_TVAL_GET_OBJECT(tv);
-+	} else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
-+		return NULL;
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE);
-+	return NULL;  /* not reachable */
-+}
-+
-+/* Useful for internal call sites where we either expect an object (function)
-+ * or a lightfunc.  Accepts an object (returned as is) or a lightfunc (coerced
-+ * to an object).  Return value is never NULL.
-+ */
-+DUK_INTERNAL duk_hobject *duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	if (DUK_TVAL_IS_OBJECT(tv)) {
-+		return DUK_TVAL_GET_OBJECT(tv);
-+	} else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
-+		duk_to_object(ctx, index);
-+		return duk_require_hobject(ctx, index);
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE);
-+	return NULL;  /* not reachable */
-+}
-+
-+DUK_EXTERNAL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (!tv) {
-+		return 0;
-+	}
-+
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED:
-+	case DUK_TAG_NULL:
-+	case DUK_TAG_BOOLEAN:
-+	case DUK_TAG_POINTER:
-+		return 0;
-+	case DUK_TAG_STRING: {
-+		duk_hstring *h = DUK_TVAL_GET_STRING(tv);
-+		DUK_ASSERT(h != NULL);
-+		return (duk_size_t) DUK_HSTRING_GET_CHARLEN(h);
-+	}
-+	case DUK_TAG_OBJECT: {
-+		duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+		return (duk_size_t) duk_hobject_get_length((duk_hthread *) ctx, h);
-+	}
-+	case DUK_TAG_BUFFER: {
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
-+		DUK_ASSERT(h != NULL);
-+		return (duk_size_t) DUK_HBUFFER_GET_SIZE(h);
-+	}
-+	case DUK_TAG_LIGHTFUNC: {
-+		duk_small_uint_t lf_flags;
-+		lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv);
-+		return (duk_size_t) DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
-+	}
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default:
-+		/* number */
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		return 0;
-+	}
-+
-+	DUK_UNREACHABLE();
-+}
-+
-+DUK_INTERNAL void duk_set_length(duk_context *ctx, duk_idx_t index, duk_size_t length) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	h = duk_get_hobject(ctx, index);
-+	if (!h) {
-+		return;
-+	}
-+
-+	duk_hobject_set_length(thr, h, (duk_uint32_t) length);  /* XXX: typing */
-+}
-+
-+/*
-+ *  Conversions and coercions
-+ *
-+ *  The conversion/coercions are in-place operations on the value stack.
-+ *  Some operations are implemented here directly, while others call a
-+ *  helper in duk_js_ops.c after validating arguments.
-+ */
-+
-+/* E5 Section 8.12.8 */
-+
-+DUK_LOCAL duk_bool_t duk__defaultvalue_coerce_attempt(duk_context *ctx, duk_idx_t index, duk_small_int_t func_stridx) {
-+	if (duk_get_prop_stridx(ctx, index, func_stridx)) {
-+		/* [ ... func ] */
-+		if (duk_is_callable(ctx, -1)) {
-+			duk_dup(ctx, index);         /* -> [ ... func this ] */
-+			duk_call_method(ctx, 0);     /* -> [ ... retval ] */
-+			if (duk_is_primitive(ctx, -1)) {
-+				duk_replace(ctx, index);
-+				return 1;
-+			}
-+			/* [ ... retval ]; popped below */
-+		}
-+	}
-+	duk_pop(ctx);  /* [ ... func/retval ] -> [ ... ] */
-+	return 0;
-+}
-+
-+DUK_EXTERNAL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+	/* inline initializer for coercers[] is not allowed by old compilers like BCC */
-+	duk_small_int_t coercers[2];
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+
-+	coercers[0] = DUK_STRIDX_VALUE_OF;
-+	coercers[1] = DUK_STRIDX_TO_STRING;
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	obj = duk_require_hobject_or_lfunc(ctx, index);
-+
-+	if (hint == DUK_HINT_NONE) {
-+		if (obj != NULL && DUK_HOBJECT_GET_CLASS_NUMBER(obj) == DUK_HOBJECT_CLASS_DATE) {
-+			hint = DUK_HINT_STRING;
-+		} else {
-+			hint = DUK_HINT_NUMBER;
-+		}
-+	}
-+
-+	if (hint == DUK_HINT_STRING) {
-+		coercers[0] = DUK_STRIDX_TO_STRING;
-+		coercers[1] = DUK_STRIDX_VALUE_OF;
-+	}
-+
-+	if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[0])) {
-+		return;
-+	}
-+
-+	if (duk__defaultvalue_coerce_attempt(ctx, index, coercers[1])) {
-+		return;
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_DEFAULTVALUE_COERCE_FAILED);
-+}
-+
-+DUK_EXTERNAL void duk_to_undefined(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_UNREF(thr);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_UNDEFINED_ACTUAL(tv);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+}
-+
-+DUK_EXTERNAL void duk_to_null(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_UNREF(thr);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_NULL(tv);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+}
-+
-+/* E5 Section 9.1 */
-+DUK_EXTERNAL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint) {
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(hint == DUK_HINT_NONE || hint == DUK_HINT_NUMBER || hint == DUK_HINT_STRING);
-+
-+	index = duk_require_normalize_index(ctx, index);
-+
-+	if (!duk_check_type_mask(ctx, index, DUK_TYPE_MASK_OBJECT |
-+	                                     DUK_TYPE_MASK_LIGHTFUNC)) {
-+		/* everything except object stay as is */
-+		return;
-+	}
-+	duk_to_defaultvalue(ctx, index, hint);
-+}
-+
-+/* E5 Section 9.2 */
-+DUK_EXTERNAL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_bool_t val;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_UNREF(thr);
-+
-+	index = duk_require_normalize_index(ctx, index);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+
-+	val = duk_js_toboolean(tv);
-+	DUK_ASSERT(val == 0 || val == 1);
-+
-+	/* Note: no need to re-lookup tv, conversion is side effect free */
-+	DUK_ASSERT(tv != NULL);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_BOOLEAN(tv, val);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+	return val;
-+}
-+
-+DUK_EXTERNAL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_double_t d;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	/* XXX: fastint? */
-+	d = duk_js_tonumber(thr, tv);
-+
-+	/* Note: need to re-lookup because ToNumber() may have side effects */
-+	tv = duk_require_tval(ctx, index);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_NUMBER(tv, d);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+	return d;
-+}
-+
-+/* XXX: combine all the integer conversions: they share everything
-+ * but the helper function for coercion.
-+ */
-+
-+typedef duk_double_t (*duk__toint_coercer)(duk_hthread *thr, duk_tval *tv);
-+
-+DUK_LOCAL duk_double_t duk__to_int_uint_helper(duk_context *ctx, duk_idx_t index, duk__toint_coercer coerce_func) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_double_t d;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	d = coerce_func(thr, tv);
-+
-+	/* XXX: fastint? */
-+
-+	/* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
-+	tv = duk_require_tval(ctx, index);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_NUMBER(tv, d);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+	return d;
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index) {
-+	/* Value coercion (in stack): ToInteger(), E5 Section 9.4
-+	 * API return value coercion: custom
-+	 */
-+	(void) duk__to_int_uint_helper(ctx, index, duk_js_tointeger);
-+	return (duk_int_t) duk__api_coerce_d2i(ctx, index, 0 /*require*/);
-+}
-+
-+DUK_EXTERNAL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index) {
-+	/* Value coercion (in stack): ToInteger(), E5 Section 9.4
-+	 * API return value coercion: custom
-+	 */
-+	(void) duk__to_int_uint_helper(ctx, index, duk_js_tointeger);
-+	return (duk_uint_t) duk__api_coerce_d2ui(ctx, index, 0 /*require*/);
-+}
-+
-+DUK_EXTERNAL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_int32_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	ret = duk_js_toint32(thr, tv);
-+
-+	/* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
-+	tv = duk_require_tval(ctx, index);
-+#if defined(DUK_USE_FASTINT)
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_FASTINT_I32(tv, ret);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+	return ret;
-+#else
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+	return ret;
-+#endif
-+}
-+
-+DUK_EXTERNAL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_uint32_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	ret = duk_js_touint32(thr, tv);
-+
-+	/* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
-+	tv = duk_require_tval(ctx, index);
-+#if defined(DUK_USE_FASTINT)
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_FASTINT_U32(tv, ret);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+	return ret;
-+#else
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+#endif
-+	return ret;
-+}
-+
-+DUK_EXTERNAL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_uint16_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	ret = duk_js_touint16(thr, tv);
-+
-+	/* Relookup in case coerce_func() has side effects, e.g. ends up coercing an object */
-+	tv = duk_require_tval(ctx, index);
-+#if defined(DUK_USE_FASTINT)
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_FASTINT_U32(tv, ret);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+	return ret;
-+#else
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+	DUK_TVAL_SET_NUMBER(tv, (duk_double_t) ret);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+#endif
-+	return ret;
-+}
-+
-+DUK_EXTERNAL const char *duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
-+	(void) duk_to_string(ctx, index);
-+	return duk_require_lstring(ctx, index, out_len);
-+}
-+
-+DUK_LOCAL duk_ret_t duk__safe_to_string_raw(duk_context *ctx) {
-+	duk_to_string(ctx, -1);
-+	return 1;
-+}
-+
-+DUK_EXTERNAL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len) {
-+	index = duk_require_normalize_index(ctx, index);
-+
-+	/* We intentionally ignore the duk_safe_call() return value and only
-+	 * check the output type.  This way we don't also need to check that
-+	 * the returned value is indeed a string in the success case.
-+	 */
-+
-+	duk_dup(ctx, index);
-+	(void) duk_safe_call(ctx, duk__safe_to_string_raw, 1 /*nargs*/, 1 /*nrets*/);
-+	if (!duk_is_string(ctx, -1)) {
-+		/* Error: try coercing error to string once. */
-+		(void) duk_safe_call(ctx, duk__safe_to_string_raw, 1 /*nargs*/, 1 /*nrets*/);
-+		if (!duk_is_string(ctx, -1)) {
-+			/* Double error */
-+			duk_pop(ctx);
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_ERROR);
-+		} else {
-+			;
-+		}
-+	} else {
-+		;
-+	}
-+	DUK_ASSERT(duk_is_string(ctx, -1));
-+
-+	duk_replace(ctx, index);
-+	return duk_require_lstring(ctx, index, out_len);
-+}
-+
-+/* XXX: other variants like uint, u32 etc */
-+DUK_INTERNAL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_double_t d, dmin, dmax;
-+	duk_int_t res;
-+	duk_bool_t clamped = 0;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+	d = duk_js_tointeger(thr, tv);  /* E5 Section 9.4, ToInteger() */
-+
-+	dmin = (duk_double_t) minval;
-+	dmax = (duk_double_t) maxval;
-+
-+	if (d < dmin) {
-+		clamped = 1;
-+		res = minval;
-+		d = dmin;
-+	} else if (d > dmax) {
-+		clamped = 1;
-+		res = maxval;
-+		d = dmax;
-+	} else {
-+		res = (duk_int_t) d;
-+	}
-+	/* 'd' and 'res' agree here */
-+
-+	/* Relookup in case duk_js_tointeger() ends up e.g. coercing an object. */
-+	tv = duk_require_tval(ctx, index);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+#if defined(DUK_USE_FASTINT)
-+#if (DUK_INT_MAX <= 0x7fffffffL)
-+	DUK_TVAL_SET_FASTINT_I32(tv, res);
-+#else
-+	/* Clamping needed if duk_int_t is 64 bits. */
-+	if (res >= DUK_FASTINT_MIN && res <= DUK_FASTINT_MAX) {
-+		DUK_TVAL_SET_FASTINT(tv, res);
-+	} else {
-+		DUK_TVAL_SET_NUMBER(tv, d);
-+	}
-+#endif
-+#else
-+	DUK_TVAL_SET_NUMBER(tv, d);  /* no need to incref */
-+#endif
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+	if (out_clamped) {
-+		*out_clamped = clamped;
-+	} else {
-+		/* coerced value is updated to value stack even when RangeError thrown */
-+		if (clamped) {
-+			DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_NUMBER_OUTSIDE_RANGE);
-+		}
-+	}
-+
-+	return res;
-+}
-+
-+DUK_INTERNAL duk_int_t duk_to_int_clamped(duk_context *ctx, duk_idx_t index, duk_idx_t minval, duk_idx_t maxval) {
-+	duk_bool_t dummy;
-+	return duk_to_int_clamped_raw(ctx, index, minval, maxval, &dummy);
-+}
-+
-+DUK_INTERNAL duk_int_t duk_to_int_check_range(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval) {
-+	return duk_to_int_clamped_raw(ctx, index, minval, maxval, NULL);  /* out_clamped==NULL -> RangeError if outside range */
-+}
-+
-+DUK_EXTERNAL const char *duk_to_string(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_UNREF(thr);
-+
-+	index = duk_require_normalize_index(ctx, index);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED: {
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_UNDEFINED);
-+		break;
-+	}
-+	case DUK_TAG_NULL: {
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_NULL);
-+		break;
-+	}
-+	case DUK_TAG_BOOLEAN: {
-+		if (DUK_TVAL_GET_BOOLEAN(tv)) {
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_TRUE);
-+		} else {
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_FALSE);
-+		}
-+		break;
-+	}
-+	case DUK_TAG_STRING: {
-+		/* nop */
-+		goto skip_replace;
-+	}
-+	case DUK_TAG_OBJECT: {
-+		duk_to_primitive(ctx, index, DUK_HINT_STRING);
-+		return duk_to_string(ctx, index);  /* Note: recursive call */
-+	}
-+	case DUK_TAG_BUFFER: {
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
-+
-+		/* Note: this allows creation of internal strings. */
-+
-+		DUK_ASSERT(h != NULL);
-+		duk_push_lstring(ctx,
-+		                 (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h),
-+		                 (duk_size_t) DUK_HBUFFER_GET_SIZE(h));
-+		break;
-+	}
-+	case DUK_TAG_POINTER: {
-+		void *ptr = DUK_TVAL_GET_POINTER(tv);
-+		if (ptr != NULL) {
-+			duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) ptr);
-+		} else {
-+			/* Represent a null pointer as 'null' to be consistent with
-+			 * the JX format variant.  Native '%p' format for a NULL
-+			 * pointer may be e.g. '(nil)'.
-+			 */
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_NULL);
-+		}
-+		break;
-+	}
-+	case DUK_TAG_LIGHTFUNC: {
-+		/* Should match Function.prototype.toString() */
-+		duk_push_lightfunc_tostring(ctx, tv);
-+		break;
-+	}
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default: {
-+		/* number */
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		duk_push_tval(ctx, tv);
-+		duk_numconv_stringify(ctx,
-+		                      10 /*radix*/,
-+		                      0 /*precision:shortest*/,
-+		                      0 /*force_exponential*/);
-+		break;
-+	}
-+	}
-+
-+	duk_replace(ctx, index);
-+
-+ skip_replace:
-+	return duk_require_string(ctx, index);
-+}
-+
-+DUK_INTERNAL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index) {
-+	duk_hstring *ret;
-+	DUK_ASSERT(ctx != NULL);
-+	duk_to_string(ctx, index);
-+	ret = duk_get_hstring(ctx, index);
-+	DUK_ASSERT(ret != NULL);
-+	return ret;
-+}
-+
-+DUK_EXTERNAL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t mode) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hbuffer *h_buf;
-+	const duk_uint8_t *src_data;
-+	duk_size_t src_size;
-+	duk_uint8_t *dst_data;
-+
-+	DUK_UNREF(thr);
-+
-+	index = duk_require_normalize_index(ctx, index);
-+
-+	h_buf = duk_get_hbuffer(ctx, index);
-+	if (h_buf != NULL) {
-+		/* Buffer is kept as is, with the fixed/dynamic nature of the
-+		 * buffer only changed if requested.
-+		 */
-+		duk_uint_t tmp;
-+
-+		src_data = (const duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_buf);
-+		src_size = DUK_HBUFFER_GET_SIZE(h_buf);
-+
-+		tmp = (DUK_HBUFFER_HAS_DYNAMIC(h_buf) ? DUK_BUF_MODE_DYNAMIC : DUK_BUF_MODE_FIXED);
-+		if (tmp == mode || mode == DUK_BUF_MODE_DONTCARE) {
-+			/* Note: src_data may be NULL if input is a zero-size
-+			 * dynamic buffer.
-+			 */
-+			dst_data = (duk_uint8_t *) src_data;
-+			goto skip_copy;
-+		}
-+	} else {
-+		/* Non-buffer value is first ToString() coerced, then converted
-+		 * to a buffer (fixed buffer is used unless a dynamic buffer is
-+		 * explicitly requested).
-+		 */
-+
-+		src_data = (const duk_uint8_t *) duk_to_lstring(ctx, index, &src_size);
-+	}
-+
-+	dst_data = (duk_uint8_t *) duk_push_buffer(ctx, src_size, (mode == DUK_BUF_MODE_DYNAMIC) /*dynamic*/);
-+	if (DUK_LIKELY(src_size > 0)) {
-+		/* When src_size == 0, src_data may be NULL (if source
-+		 * buffer is dynamic), and dst_data may be NULL (if
-+		 * target buffer is dynamic).  Avoid zero-size memcpy()
-+		 * with an invalid pointer.
-+		 */
-+		DUK_MEMCPY(dst_data, src_data, src_size);
-+	}
-+	duk_replace(ctx, index);
-+ skip_copy:
-+
-+	if (out_size) {
-+		*out_size = src_size;
-+	}
-+	return dst_data;
-+}
-+
-+DUK_EXTERNAL void *duk_to_pointer(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+	void *res;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	index = duk_require_normalize_index(ctx, index);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED:
-+	case DUK_TAG_NULL:
-+	case DUK_TAG_BOOLEAN:
-+		res = NULL;
-+		break;
-+	case DUK_TAG_POINTER:
-+		res = DUK_TVAL_GET_POINTER(tv);
-+		break;
-+	case DUK_TAG_STRING:
-+	case DUK_TAG_OBJECT:
-+	case DUK_TAG_BUFFER:
-+		/* Heap allocated: return heap pointer which is NOT useful
-+		 * for the caller, except for debugging.
-+		 */
-+		res = (void *) DUK_TVAL_GET_HEAPHDR(tv);
-+		break;
-+	case DUK_TAG_LIGHTFUNC:
-+		/* Function pointers do not always cast correctly to void *
-+		 * (depends on memory and segmentation model for instance),
-+		 * so they coerce to NULL.
-+		 */
-+		res = NULL;
-+		break;
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default:
-+		/* number */
-+		res = NULL;
-+		break;
-+	}
-+
-+	duk_push_pointer(ctx, res);
-+	duk_replace(ctx, index);
-+	return res;
-+}
-+
-+DUK_EXTERNAL void duk_to_object(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_uint_t flags = 0;   /* shared flags for a subset of types */
-+	duk_small_int_t proto = 0;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	index = duk_require_normalize_index(ctx, index);
-+
-+	tv = duk_require_tval(ctx, index);
-+	DUK_ASSERT(tv != NULL);
-+
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED:
-+	case DUK_TAG_NULL: {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_OBJECT_COERCIBLE);
-+		break;
-+	}
-+	case DUK_TAG_BOOLEAN: {
-+		flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BOOLEAN);
-+		proto = DUK_BIDX_BOOLEAN_PROTOTYPE;
-+		goto create_object;
-+	}
-+	case DUK_TAG_STRING: {
-+		flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		        DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ |
-+		        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_STRING);
-+		proto = DUK_BIDX_STRING_PROTOTYPE;
-+		goto create_object;
-+	}
-+	case DUK_TAG_OBJECT: {
-+		/* nop */
-+		break;
-+	}
-+	case DUK_TAG_BUFFER: {
-+		flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		        DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ |
-+		        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER);
-+		proto = DUK_BIDX_BUFFER_PROTOTYPE;
-+		goto create_object;
-+	}
-+	case DUK_TAG_POINTER: {
-+		flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_POINTER);
-+		proto = DUK_BIDX_POINTER_PROTOTYPE;
-+		goto create_object;
-+	}
-+	case DUK_TAG_LIGHTFUNC: {
-+		/* Lightfunc coerces to a Function instance with concrete
-+		 * properties.  Since 'length' is virtual for Duktape/C
-+		 * functions, don't need to define that.
-+		 *
-+		 * The result is made extensible to mimic what happens to
-+		 * strings:
-+		 *   > Object.isExtensible(Object('foo'))
-+		 *   true
-+		 */
-+		duk_small_uint_t lf_flags;
-+		duk_small_uint_t nargs;
-+		duk_small_uint_t lf_len;
-+		duk_c_function func;
-+		duk_hnativefunction *nf;
-+
-+		DUK_TVAL_GET_LIGHTFUNC(tv, func, lf_flags);
-+
-+		nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags);
-+		if (nargs == DUK_LFUNC_NARGS_VARARGS) {
-+			nargs = DUK_VARARGS;
-+		}
-+		flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		        DUK_HOBJECT_FLAG_CONSTRUCTABLE |
-+		        DUK_HOBJECT_FLAG_NATIVEFUNCTION |
-+	                DUK_HOBJECT_FLAG_NEWENV |
-+	                DUK_HOBJECT_FLAG_STRICT |
-+	                DUK_HOBJECT_FLAG_NOTAIL |
-+			/* DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC: omitted here intentionally */
-+	                DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
-+		(void) duk__push_c_function_raw(ctx, func, (duk_idx_t) nargs, flags);
-+
-+		lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
-+		if (lf_len != nargs) {
-+			/* Explicit length is only needed if it differs from 'nargs'. */
-+			duk_push_int(ctx, (duk_int_t) lf_len);
-+			duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
-+		}
-+		duk_push_lightfunc_name(ctx, tv);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
-+
-+		nf = duk_get_hnativefunction(ctx, -1);
-+		DUK_ASSERT(nf != NULL);
-+		nf->magic = (duk_int16_t) DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags);
-+
-+		/* Enable DUKFUNC exotic behavior once properties are set up. */
-+		DUK_HOBJECT_SET_EXOTIC_DUKFUNC((duk_hobject *) nf);
-+		goto replace_value;
-+	}
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default: {
-+		flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		               DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_NUMBER);
-+		proto = DUK_BIDX_NUMBER_PROTOTYPE;
-+		goto create_object;
-+	}
-+	}
-+	return;
-+
-+ create_object:
-+	(void) duk_push_object_helper(ctx, flags, proto);
-+
-+	/* Note: Boolean prototype's internal value property is not writable,
-+	 * but duk_xdef_prop_stridx() disregards the write protection.  Boolean
-+	 * instances are immutable.
-+	 *
-+	 * String and buffer special behaviors are already enabled which is not
-+	 * ideal, but a write to the internal value is not affected by them.
-+	 */
-+	duk_dup(ctx, index);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
-+
-+ replace_value:
-+	duk_replace(ctx, index);
-+}
-+
-+/*
-+ *  Type checking
-+ */
-+
-+DUK_LOCAL duk_bool_t duk__tag_check(duk_context *ctx, duk_idx_t index, duk_small_uint_t tag) {
-+	duk_tval *tv;
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (!tv) {
-+		return 0;
-+	}
-+	return (DUK_TVAL_GET_TAG(tv) == tag);
-+}
-+
-+DUK_LOCAL duk_bool_t duk__obj_flag_any_default_false(duk_context *ctx, duk_idx_t index, duk_uint_t flag_mask) {
-+	duk_hobject *obj;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj = duk_get_hobject(ctx, index);
-+	if (obj) {
-+		return (DUK_HEAPHDR_CHECK_FLAG_BITS((duk_heaphdr *) obj, flag_mask) ? 1 : 0);
-+	}
-+	return 0;
-+}
-+
-+DUK_EXTERNAL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (!tv) {
-+		return DUK_TYPE_NONE;
-+	}
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED:
-+		return DUK_TYPE_UNDEFINED;
-+	case DUK_TAG_NULL:
-+		return DUK_TYPE_NULL;
-+	case DUK_TAG_BOOLEAN:
-+		return DUK_TYPE_BOOLEAN;
-+	case DUK_TAG_STRING:
-+		return DUK_TYPE_STRING;
-+	case DUK_TAG_OBJECT:
-+		return DUK_TYPE_OBJECT;
-+	case DUK_TAG_BUFFER:
-+		return DUK_TYPE_BUFFER;
-+	case DUK_TAG_POINTER:
-+		return DUK_TYPE_POINTER;
-+	case DUK_TAG_LIGHTFUNC:
-+		return DUK_TYPE_LIGHTFUNC;
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default:
-+		/* Note: number has no explicit tag (in 8-byte representation) */
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		return DUK_TYPE_NUMBER;
-+	}
-+	DUK_UNREACHABLE();
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type) {
-+	return (duk_get_type(ctx, index) == type) ? 1 : 0;
-+}
-+
-+DUK_EXTERNAL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (!tv) {
-+		return DUK_TYPE_MASK_NONE;
-+	}
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED:
-+		return DUK_TYPE_MASK_UNDEFINED;
-+	case DUK_TAG_NULL:
-+		return DUK_TYPE_MASK_NULL;
-+	case DUK_TAG_BOOLEAN:
-+		return DUK_TYPE_MASK_BOOLEAN;
-+	case DUK_TAG_STRING:
-+		return DUK_TYPE_MASK_STRING;
-+	case DUK_TAG_OBJECT:
-+		return DUK_TYPE_MASK_OBJECT;
-+	case DUK_TAG_BUFFER:
-+		return DUK_TYPE_MASK_BUFFER;
-+	case DUK_TAG_POINTER:
-+		return DUK_TYPE_MASK_POINTER;
-+	case DUK_TAG_LIGHTFUNC:
-+		return DUK_TYPE_MASK_LIGHTFUNC;
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default:
-+		/* Note: number has no explicit tag (in 8-byte representation) */
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		return DUK_TYPE_MASK_NUMBER;
-+	}
-+	DUK_UNREACHABLE();
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	DUK_ASSERT(ctx != NULL);
-+	if (duk_get_type_mask(ctx, index) & mask) {
-+		return 1;
-+	}
-+	if (mask & DUK_TYPE_MASK_THROW) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_UNEXPECTED_TYPE);
-+		DUK_UNREACHABLE();
-+	}
-+	return 0;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return duk__tag_check(ctx, index, DUK_TAG_UNDEFINED);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return duk__tag_check(ctx, index, DUK_TAG_NULL);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+	duk_small_uint_t tag;
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (!tv) {
-+		return 0;
-+	}
-+	tag = DUK_TVAL_GET_TAG(tv);
-+	return (tag == DUK_TAG_UNDEFINED) || (tag == DUK_TAG_NULL);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return duk__tag_check(ctx, index, DUK_TAG_BOOLEAN);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/*
-+	 *  Number is special because it doesn't have a specific
-+	 *  tag in the 8-byte representation.
-+	 */
-+
-+	/* XXX: shorter version for 12-byte representation? */
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (!tv) {
-+		return 0;
-+	}
-+	return DUK_TVAL_IS_NUMBER(tv);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index) {
-+	/* XXX: This will now return false for non-numbers, even though they would
-+	 * coerce to NaN (as a general rule).  In particular, duk_get_number()
-+	 * returns a NaN for non-numbers, so should this function also return
-+	 * true for non-numbers?
-+	 */
-+
-+	duk_tval *tv;
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (!tv || !DUK_TVAL_IS_NUMBER(tv)) {
-+		return 0;
-+	}
-+	return DUK_ISNAN(DUK_TVAL_GET_NUMBER(tv));
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return duk__tag_check(ctx, index, DUK_TAG_STRING);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return duk__tag_check(ctx, index, DUK_TAG_OBJECT);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return duk__tag_check(ctx, index, DUK_TAG_BUFFER);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return duk__tag_check(ctx, index, DUK_TAG_POINTER);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return duk__tag_check(ctx, index, DUK_TAG_LIGHTFUNC);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index) {
-+	duk_hobject *obj;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	obj = duk_get_hobject(ctx, index);
-+	if (obj) {
-+		return (DUK_HOBJECT_GET_CLASS_NUMBER(obj) == DUK_HOBJECT_CLASS_ARRAY ? 1 : 0);
-+	}
-+	return 0;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_LIGHTFUNC(tv)) {
-+		return 1;
-+	}
-+	return duk__obj_flag_any_default_false(ctx,
-+	                                       index,
-+	                                       DUK_HOBJECT_FLAG_COMPILEDFUNCTION |
-+	                                       DUK_HOBJECT_FLAG_NATIVEFUNCTION |
-+	                                       DUK_HOBJECT_FLAG_BOUND);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t index) {
-+	return duk__obj_flag_any_default_false(ctx,
-+	                                       index,
-+	                                       DUK_HOBJECT_FLAG_NATIVEFUNCTION);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t index) {
-+	return duk__obj_flag_any_default_false(ctx,
-+	                                       index,
-+	                                       DUK_HOBJECT_FLAG_COMPILEDFUNCTION);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index) {
-+	return duk__obj_flag_any_default_false(ctx,
-+	                                       index,
-+	                                       DUK_HOBJECT_FLAG_BOUND);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index) {
-+	return duk__obj_flag_any_default_false(ctx,
-+	                                       index,
-+	                                       DUK_HOBJECT_FLAG_THREAD);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_callable(duk_context *ctx, duk_idx_t index) {
-+	/* XXX: currently same as duk_is_function() */
-+	return duk_is_function(ctx, index);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_BUFFER(tv)) {
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
-+		DUK_ASSERT(h != NULL);
-+		return (DUK_HBUFFER_HAS_DYNAMIC(h) ? 1 : 0);
-+	}
-+	return 0;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	tv = duk_get_tval(ctx, index);
-+	if (tv && DUK_TVAL_IS_BUFFER(tv)) {
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
-+		DUK_ASSERT(h != NULL);
-+		return (DUK_HBUFFER_HAS_DYNAMIC(h) ? 0 : 1);
-+	}
-+	return 0;
-+}
-+
-+/* XXX: make macro in API */
-+DUK_EXTERNAL duk_bool_t duk_is_primitive(duk_context *ctx, duk_idx_t index) {
-+	DUK_ASSERT(ctx != NULL);
-+	return !duk_is_object(ctx, index);
-+}
-+
-+DUK_EXTERNAL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h;
-+	duk_uint_t sanity;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	h = duk_get_hobject(ctx, index);
-+
-+	sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
-+	do {
-+		if (!h) {
-+			return DUK_ERR_NONE;
-+		}
-+		if (h == thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE]) {
-+			return DUK_ERR_EVAL_ERROR;
-+		}
-+		if (h == thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE]) {
-+			return DUK_ERR_RANGE_ERROR;
-+		}
-+		if (h == thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE]) {
-+			return DUK_ERR_REFERENCE_ERROR;
-+		}
-+		if (h == thr->builtins[DUK_BIDX_SYNTAX_ERROR_PROTOTYPE]) {
-+			return DUK_ERR_SYNTAX_ERROR;
-+		}
-+		if (h == thr->builtins[DUK_BIDX_TYPE_ERROR_PROTOTYPE]) {
-+			return DUK_ERR_TYPE_ERROR;
-+		}
-+		if (h == thr->builtins[DUK_BIDX_URI_ERROR_PROTOTYPE]) {
-+			return DUK_ERR_URI_ERROR;
-+		}
-+		if (h == thr->builtins[DUK_BIDX_ERROR_PROTOTYPE]) {
-+			return DUK_ERR_ERROR;
-+		}
-+
-+		h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
-+	} while (--sanity > 0);
-+
-+	return DUK_ERR_NONE;
-+}
-+
-+/*
-+ *  Pushers
-+ */
-+
-+DUK_INTERNAL void duk_push_tval(duk_context *ctx, duk_tval *tv) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(tv != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_TVAL(tv_slot, tv);
-+	DUK_TVAL_INCREF(thr, tv);  /* no side effects */
-+}
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+/* Right now only needed by the debugger. */
-+DUK_INTERNAL void duk_push_unused(duk_context *ctx) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(tv_slot);
-+}
-+#endif
-+
-+DUK_EXTERNAL void duk_push_undefined(duk_context *ctx) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_UNDEFINED_ACTUAL(tv_slot);
-+}
-+
-+DUK_EXTERNAL void duk_push_null(duk_context *ctx) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_NULL(tv_slot);
-+}
-+
-+DUK_EXTERNAL void duk_push_boolean(duk_context *ctx, duk_bool_t val) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+	duk_small_int_t b;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	b = (val ? 1 : 0);  /* ensure value is 1 or 0 (not other non-zero) */
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_BOOLEAN(tv_slot, b);
-+}
-+
-+DUK_EXTERNAL void duk_push_true(duk_context *ctx) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_BOOLEAN_TRUE(tv_slot);
-+}
-+
-+DUK_EXTERNAL void duk_push_false(duk_context *ctx) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_BOOLEAN_FALSE(tv_slot);
-+}
-+
-+/* normalize NaN which may not match our canonical internal NaN */
-+DUK_EXTERNAL void duk_push_number(duk_context *ctx, duk_double_t val) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+	duk_double_union du;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	du.d = val;
-+	DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_NUMBER(tv_slot, du.d);
-+}
-+
-+DUK_EXTERNAL void duk_push_int(duk_context *ctx, duk_int_t val) {
-+#if defined(DUK_USE_FASTINT)
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+#if DUK_INT_MAX <= 0x7fffffffL
-+	DUK_TVAL_SET_FASTINT_I32(tv_slot, (duk_int32_t) val);
-+#else
-+	if (val >= DUK_FASTINT_MIN && val <= DUK_FASTINT_MAX) {
-+		DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val);
-+	} else {
-+		duk_double_t = (duk_double_t) val;
-+		DUK_TVAL_SET_NUMBER(tv_slot, d);
-+	}
-+#endif
-+#else  /* DUK_USE_FASTINT */
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+	duk_double_t d;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	d = (duk_double_t) val;
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_NUMBER(tv_slot, d);
-+#endif  /* DUK_USE_FASTINT */
-+}
-+
-+DUK_EXTERNAL void duk_push_uint(duk_context *ctx, duk_uint_t val) {
-+#if defined(DUK_USE_FASTINT)
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+#if DUK_UINT_MAX <= 0xffffffffUL
-+	DUK_TVAL_SET_FASTINT_U32(tv_slot, (duk_uint32_t) val);
-+#else
-+	if (val <= DUK_FASTINT_MAX) {  /* val is unsigned so >= 0 */
-+		/* XXX: take advantage of val being unsigned, no need to mask */
-+		DUK_TVAL_SET_FASTINT(tv_slot, (duk_int64_t) val);
-+	} else {
-+		duk_double_t = (duk_double_t) val;
-+		DUK_TVAL_SET_NUMBER(tv_slot, d);
-+	}
-+#endif
-+#else  /* DUK_USE_FASTINT */
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+	duk_double_t d;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	d = (duk_double_t) val;
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_NUMBER(tv_slot, d);
-+#endif  /* DUK_USE_FASTINT */
-+}
-+
-+DUK_EXTERNAL void duk_push_nan(duk_context *ctx) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+	duk_double_union du;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	DUK_DBLUNION_SET_NAN(&du);
-+	DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_NUMBER(tv_slot, du.d);
-+}
-+
-+DUK_EXTERNAL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* check stack before interning (avoid hanging temp) */
-+	if (thr->valstack_top >= thr->valstack_end) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
-+	}
-+
-+	/* NULL with zero length represents an empty string; NULL with higher
-+	 * length is also now trated like an empty string although it is
-+	 * a bit dubious.  This is unlike duk_push_string() which pushes a
-+	 * 'null' if the input string is a NULL.
-+	 */
-+	if (!str) {
-+		len = 0;
-+	}
-+
-+	/* Check for maximum string length */
-+	if (len > DUK_HSTRING_MAX_BYTELEN) {
-+		DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_STRING_TOO_LONG);
-+	}
-+
-+	h = duk_heap_string_intern_checked(thr, (duk_uint8_t *) str, (duk_uint32_t) len);
-+	DUK_ASSERT(h != NULL);
-+
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_STRING(tv_slot, h);
-+	DUK_HSTRING_INCREF(thr, h);  /* no side effects */
-+
-+	return (const char *) DUK_HSTRING_GET_DATA(h);
-+}
-+
-+DUK_EXTERNAL const char *duk_push_string(duk_context *ctx, const char *str) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	if (str) {
-+		return duk_push_lstring(ctx, str, DUK_STRLEN(str));
-+	} else {
-+		duk_push_null(ctx);
-+		return NULL;
-+	}
-+}
-+
-+#ifdef DUK_USE_FILE_IO
-+/* This is a bit clunky because it is ANSI C portable.  Should perhaps
-+ * relocate to another file because this is potentially platform
-+ * dependent.
-+ */
-+DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_file *f = NULL;
-+	char *buf;
-+	long sz;  /* ANSI C typing */
-+
-+	DUK_ASSERT(ctx != NULL);
-+	if (!path) {
-+		goto fail;
-+	}
-+	f = DUK_FOPEN(path, "rb");
-+	if (!f) {
-+		goto fail;
-+	}
-+	if (DUK_FSEEK(f, 0, SEEK_END) < 0) {
-+		goto fail;
-+	}
-+	sz = DUK_FTELL(f);
-+	if (sz < 0) {
-+		goto fail;
-+	}
-+	if (DUK_FSEEK(f, 0, SEEK_SET) < 0) {
-+		goto fail;
-+	}
-+	buf = (char *) duk_push_fixed_buffer(ctx, (duk_size_t) sz);
-+	DUK_ASSERT(buf != NULL);
-+	if ((duk_size_t) DUK_FREAD(buf, 1, (size_t) sz, f) != (duk_size_t) sz) {
-+		goto fail;
-+	}
-+	(void) DUK_FCLOSE(f);  /* ignore fclose() error */
-+	f = NULL;
-+	return duk_to_string(ctx, -1);
-+
-+ fail:
-+	if (f) {
-+		DUK_FCLOSE(f);
-+	}
-+
-+	if (flags != 0) {
-+		DUK_ASSERT(flags == DUK_STRING_PUSH_SAFE);  /* only flag now */
-+		duk_push_undefined(ctx);
-+	} else {
-+		/* XXX: string not shared because it is conditional */
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "read file error");
-+	}
-+	return NULL;
-+}
-+#else
-+DUK_EXTERNAL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_UNREF(path);
-+
-+	if (flags != 0) {
-+		DUK_ASSERT(flags == DUK_STRING_PUSH_SAFE);  /* only flag now */
-+		duk_push_undefined(ctx);
-+	} else {
-+		/* XXX: string not shared because it is conditional */
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "file I/O disabled");
-+	}
-+	return NULL;
-+}
-+#endif  /* DUK_USE_FILE_IO */
-+
-+DUK_EXTERNAL void duk_push_pointer(duk_context *ctx, void *val) {
-+	duk_hthread *thr;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	thr = (duk_hthread *) ctx;
-+	DUK__CHECK_SPACE();
-+	tv_slot = thr->valstack_top++;
-+	DUK_TVAL_SET_POINTER(tv_slot, val);
-+}
-+
-+#define DUK__PUSH_THIS_FLAG_CHECK_COERC  (1 << 0)
-+#define DUK__PUSH_THIS_FLAG_TO_OBJECT    (1 << 1)
-+#define DUK__PUSH_THIS_FLAG_TO_STRING    (1 << 2)
-+
-+DUK_LOCAL void duk__push_this_helper(duk_context *ctx, duk_small_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(thr->callstack_top >= 0);  /* avoid warning (unsigned) */
-+	DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
-+
-+	if (thr->callstack_top == 0) {
-+		if (flags & DUK__PUSH_THIS_FLAG_CHECK_COERC) {
-+			goto type_error;
-+		}
-+		duk_push_undefined(ctx);
-+	} else {
-+		duk_tval tv_tmp;
-+		duk_tval *tv;
-+
-+		/* 'this' binding is just before current activation's bottom */
-+		DUK_ASSERT(thr->valstack_bottom > thr->valstack);
-+		tv = thr->valstack_bottom - 1;
-+		if (flags & DUK__PUSH_THIS_FLAG_CHECK_COERC) {
-+			if (DUK_TVAL_IS_UNDEFINED(tv) || DUK_TVAL_IS_NULL(tv)) {
-+				goto type_error;
-+			}
-+		}
-+
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+		duk_push_tval(ctx, &tv_tmp);
-+	}
-+
-+	if (flags & DUK__PUSH_THIS_FLAG_TO_OBJECT) {
-+		duk_to_object(ctx, -1);
-+	} else if (flags & DUK__PUSH_THIS_FLAG_TO_STRING) {
-+		duk_to_string(ctx, -1);
-+	}
-+
-+	return;
-+
-+ type_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_OBJECT_COERCIBLE);
-+}
-+
-+DUK_EXTERNAL void duk_push_this(duk_context *ctx) {
-+	duk__push_this_helper(ctx, 0 /*flags*/);
-+}
-+
-+DUK_INTERNAL void duk_push_this_check_object_coercible(duk_context *ctx) {
-+	duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC /*flags*/);
-+}
-+
-+DUK_INTERNAL duk_hobject *duk_push_this_coercible_to_object(duk_context *ctx) {
-+	duk_hobject *h;
-+	duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC |
-+	                           DUK__PUSH_THIS_FLAG_TO_OBJECT /*flags*/);
-+	h = duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(h != NULL);
-+	return h;
-+}
-+
-+DUK_INTERNAL duk_hstring *duk_push_this_coercible_to_string(duk_context *ctx) {
-+	duk_hstring *h;
-+	duk__push_this_helper(ctx, DUK__PUSH_THIS_FLAG_CHECK_COERC |
-+	                           DUK__PUSH_THIS_FLAG_TO_STRING /*flags*/);
-+	h = duk_get_hstring(ctx, -1);
-+	DUK_ASSERT(h != NULL);
-+	return h;
-+}
-+
-+DUK_EXTERNAL void duk_push_current_function(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_activation *act;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT_DISABLE(thr->callstack_top >= 0);
-+	DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
-+
-+	act = duk_hthread_get_current_activation(thr);
-+	if (act) {
-+		duk_push_tval(ctx, &act->tv_func);
-+	} else {
-+		duk_push_undefined(ctx);
-+	}
-+}
-+
-+DUK_EXTERNAL void duk_push_current_thread(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+
-+	if (thr->heap->curr_thread) {
-+		duk_push_hobject(ctx, (duk_hobject *) thr->heap->curr_thread);
-+	} else {
-+		duk_push_undefined(ctx);
-+	}
-+}
-+
-+DUK_EXTERNAL void duk_push_global_object(duk_context *ctx) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	duk_push_hobject_bidx(ctx, DUK_BIDX_GLOBAL);
-+}
-+
-+/* XXX: size optimize */
-+DUK_LOCAL void duk__push_stash(duk_context *ctx) {
-+	DUK_ASSERT(ctx != NULL);
-+	if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE)) {
-+		DUK_DDD(DUK_DDDPRINT("creating heap/global/thread stash on first use"));
-+		duk_pop(ctx);
-+		duk_push_object_internal(ctx);
-+		duk_dup_top(ctx);
-+		duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_C);  /* [ ... parent stash stash ] -> [ ... parent stash ] */
-+	}
-+	duk_remove(ctx, -2);
-+}
-+
-+DUK_EXTERNAL void duk_push_heap_stash(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_heap *heap;
-+	DUK_ASSERT(ctx != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap->heap_object != NULL);
-+	duk_push_hobject(ctx, heap->heap_object);
-+	duk__push_stash(ctx);
-+}
-+
-+DUK_EXTERNAL void duk_push_global_stash(duk_context *ctx) {
-+	DUK_ASSERT(ctx != NULL);
-+	duk_push_global_object(ctx);
-+	duk__push_stash(ctx);
-+}
-+
-+DUK_EXTERNAL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	DUK_ASSERT(ctx != NULL);
-+	if (!target_ctx) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+		return;  /* not reached */
-+	}
-+	duk_push_hobject(ctx, (duk_hobject *) target_ctx);
-+	duk__push_stash(ctx);
-+}
-+
-+/* XXX: duk_ssize_t would be useful here */
-+DUK_LOCAL duk_int_t duk__try_push_vsprintf(duk_context *ctx, void *buf, duk_size_t sz, const char *fmt, va_list ap) {
-+	duk_int_t len;
-+
-+	DUK_UNREF(ctx);
-+
-+	/* NUL terminator handling doesn't matter here */
-+	len = DUK_VSNPRINTF((char *) buf, sz, fmt, ap);
-+	if (len < (duk_int_t) sz) {
-+		/* Return value of 'sz' or more indicates output was (potentially)
-+		 * truncated.
-+		 */
-+		return (duk_int_t) len;
-+	}
-+	return -1;
-+}
-+
-+DUK_EXTERNAL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_uint8_t stack_buf[DUK_PUSH_SPRINTF_INITIAL_SIZE];
-+	duk_size_t sz = DUK_PUSH_SPRINTF_INITIAL_SIZE;
-+	duk_bool_t pushed_buf = 0;
-+	void *buf;
-+	duk_int_t len;  /* XXX: duk_ssize_t */
-+	const char *res;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* special handling of fmt==NULL */
-+	if (!fmt) {
-+		duk_hstring *h_str;
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
-+		h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr);  /* rely on interning, must be this string */
-+		return (const char *) DUK_HSTRING_GET_DATA(h_str);
-+	}
-+
-+	/* initial estimate based on format string */
-+	sz = DUK_STRLEN(fmt) + 16;  /* format plus something to avoid just missing */
-+	if (sz < DUK_PUSH_SPRINTF_INITIAL_SIZE) {
-+		sz = DUK_PUSH_SPRINTF_INITIAL_SIZE;
-+	}
-+	DUK_ASSERT(sz > 0);
-+
-+	/* Try to make do with a stack buffer to avoid allocating a temporary buffer.
-+	 * This works 99% of the time which is quite nice.
-+	 */
-+	for (;;) {
-+		va_list ap_copy;  /* copied so that 'ap' can be reused */
-+
-+		if (sz <= sizeof(stack_buf)) {
-+			buf = stack_buf;
-+		} else if (!pushed_buf) {
-+			pushed_buf = 1;
-+			buf = duk_push_dynamic_buffer(ctx, sz);
-+		} else {
-+			buf = duk_resize_buffer(ctx, -1, sz);
-+		}
-+		DUK_ASSERT(buf != NULL);
-+
-+		DUK_VA_COPY(ap_copy, ap);
-+		len = duk__try_push_vsprintf(ctx, buf, sz, fmt, ap_copy);
-+		va_end(ap_copy);
-+		if (len >= 0) {
-+			break;
-+		}
-+
-+		/* failed, resize and try again */
-+		sz = sz * 2;
-+		if (sz >= DUK_PUSH_SPRINTF_SANITY_LIMIT) {
-+			DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_SPRINTF_TOO_LONG);
-+		}
-+	}
-+
-+	/* Cannot use duk_to_string() on the buffer because it is usually
-+	 * larger than 'len'.  Also, 'buf' is usually a stack buffer.
-+	 */
-+	res = duk_push_lstring(ctx, (const char *) buf, (duk_size_t) len);  /* [ buf? res ] */
-+	if (pushed_buf) {
-+		duk_remove(ctx, -2);
-+	}
-+	return res;
-+}
-+
-+DUK_EXTERNAL const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ...) {
-+	va_list ap;
-+	const char *ret;
-+
-+	/* allow fmt==NULL */
-+	va_start(ap, fmt);
-+	ret = duk_push_vsprintf(ctx, fmt, ap);
-+	va_end(ap);
-+
-+	return ret;
-+}
-+
-+DUK_INTERNAL duk_idx_t duk_push_object_helper(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv_slot;
-+	duk_hobject *h;
-+	duk_idx_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(prototype_bidx == -1 ||
-+	           (prototype_bidx >= 0 && prototype_bidx < DUK_NUM_BUILTINS));
-+
-+	/* check stack first */
-+	if (thr->valstack_top >= thr->valstack_end) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
-+	}
-+
-+	h = duk_hobject_alloc(thr->heap, hobject_flags_and_class);
-+	if (!h) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_OBJECT_ALLOC_FAILED);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("created object with flags: 0x%08lx", (unsigned long) h->hdr.h_flags));
-+
-+	tv_slot = thr->valstack_top;
-+	DUK_TVAL_SET_OBJECT(tv_slot, h);
-+	DUK_HOBJECT_INCREF(thr, h);  /* no side effects */
-+	ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	thr->valstack_top++;
-+
-+	/* object is now reachable */
-+
-+	if (prototype_bidx >= 0) {
-+		DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[prototype_bidx]);
-+	} else {
-+		DUK_ASSERT(prototype_bidx == -1);
-+		DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h) == NULL);
-+	}
-+
-+	return ret;
-+}
-+
-+DUK_INTERNAL duk_idx_t duk_push_object_helper_proto(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_hobject *proto) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t ret;
-+	duk_hobject *h;
-+
-+	ret = duk_push_object_helper(ctx, hobject_flags_and_class, -1);
-+	h = duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(h != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h) == NULL);
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, proto);
-+	return ret;
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_push_object(duk_context *ctx) {
-+	return duk_push_object_helper(ctx,
-+	                              DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                              DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-+	                              DUK_BIDX_OBJECT_PROTOTYPE);
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_push_array(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+	duk_idx_t ret;
-+
-+	ret = duk_push_object_helper(ctx,
-+	                             DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                             DUK_HOBJECT_FLAG_ARRAY_PART |
-+	                             DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARRAY),
-+	                             DUK_BIDX_ARRAY_PROTOTYPE);
-+
-+	obj = duk_require_hobject(ctx, ret);
-+
-+	/*
-+	 *  An array must have a 'length' property (E5 Section 15.4.5.2).
-+	 *  The special array behavior flag must only be enabled once the
-+	 *  length property has been added.
-+	 *
-+	 *  The internal property must be a number (and preferably a
-+	 *  fastint if fastint support is enabled).
-+	 */
-+
-+	duk_push_int(ctx, 0);
-+#if defined(DUK_USE_FASTINT)
-+	DUK_ASSERT(DUK_TVAL_IS_FASTINT(duk_require_tval(ctx, -1)));
-+#endif
-+
-+	duk_hobject_define_property_internal(thr,
-+	                                     obj,
-+	                                     DUK_HTHREAD_STRING_LENGTH(thr),
-+	                                     DUK_PROPDESC_FLAGS_W);
-+	DUK_HOBJECT_SET_EXOTIC_ARRAY(obj);
-+
-+	return ret;
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hthread *obj;
-+	duk_idx_t ret;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* check stack first */
-+	if (thr->valstack_top >= thr->valstack_end) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
-+	}
-+
-+	obj = duk_hthread_alloc(thr->heap,
-+	                        DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                        DUK_HOBJECT_FLAG_THREAD |
-+	                        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD));
-+	if (!obj) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_THREAD_ALLOC_FAILED);
-+	}
-+	obj->state = DUK_HTHREAD_STATE_INACTIVE;
-+#if defined(DUK_USE_HEAPPTR16)
-+	obj->strs16 = thr->strs16;
-+#else
-+	obj->strs = thr->strs;
-+#endif
-+	DUK_DDD(DUK_DDDPRINT("created thread object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags));
-+
-+	/* make the new thread reachable */
-+	tv_slot = thr->valstack_top;
-+	DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
-+	DUK_HTHREAD_INCREF(thr, obj);
-+	ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	thr->valstack_top++;
-+
-+	/* important to do this *after* pushing, to make the thread reachable for gc */
-+	if (!duk_hthread_init_stacks(thr->heap, obj)) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_THREAD_ALLOC_FAILED);
-+	}
-+
-+	/* initialize built-ins - either by copying or creating new ones */
-+	if (flags & DUK_THREAD_NEW_GLOBAL_ENV) {
-+		duk_hthread_create_builtin_objects(obj);
-+	} else {
-+		duk_hthread_copy_builtin_objects(thr, obj);
-+	}
-+
-+	/* default prototype (Note: 'obj' must be reachable) */
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, obj->builtins[DUK_BIDX_THREAD_PROTOTYPE]);
-+
-+	/* Initial stack size satisfies the stack spare constraints so there
-+	 * is no need to require stack here.
-+	 */
-+	DUK_ASSERT(DUK_VALSTACK_INITIAL_SIZE >=
-+	           DUK_VALSTACK_API_ENTRY_MINIMUM + DUK_VALSTACK_INTERNAL_EXTRA);
-+
-+	return ret;
-+}
-+
-+DUK_INTERNAL duk_idx_t duk_push_compiledfunction(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hcompiledfunction *obj;
-+	duk_idx_t ret;
-+	duk_tval *tv_slot;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* check stack first */
-+	if (thr->valstack_top >= thr->valstack_end) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
-+	}
-+
-+	/* Template functions are not strictly constructable (they don't
-+	 * have a "prototype" property for instance), so leave the
-+	 * DUK_HOBJECT_FLAG_CONSRUCTABLE flag cleared here.
-+	 */
-+
-+	obj = duk_hcompiledfunction_alloc(thr->heap,
-+	                                  DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                                  DUK_HOBJECT_FLAG_COMPILEDFUNCTION |
-+	                                  DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION));
-+	if (!obj) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_FUNC_ALLOC_FAILED);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("created compiled function object with flags: 0x%08lx", (unsigned long) obj->obj.hdr.h_flags));
-+
-+	tv_slot = thr->valstack_top;
-+	DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
-+	DUK_HOBJECT_INCREF(thr, obj);
-+	ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	thr->valstack_top++;
-+
-+	/* default prototype (Note: 'obj' must be reachable) */
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
-+
-+	return ret;
-+}
-+
-+DUK_LOCAL duk_idx_t duk__push_c_function_raw(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hnativefunction *obj;
-+	duk_idx_t ret;
-+	duk_tval *tv_slot;
-+	duk_uint16_t func_nargs;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* check stack first */
-+	if (thr->valstack_top >= thr->valstack_end) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
-+	}
-+	if (func == NULL) {
-+		goto api_error;
-+	}
-+	if (nargs >= 0 && nargs < DUK_HNATIVEFUNCTION_NARGS_MAX) {
-+		func_nargs = (duk_uint16_t) nargs;
-+	} else if (nargs == DUK_VARARGS) {
-+		func_nargs = DUK_HNATIVEFUNCTION_NARGS_VARARGS;
-+	} else {
-+		goto api_error;
-+	}
-+
-+	obj = duk_hnativefunction_alloc(thr->heap, flags);
-+	if (!obj) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_FUNC_ALLOC_FAILED);
-+	}
-+
-+	obj->func = func;
-+	obj->nargs = func_nargs;
-+
-+	DUK_DDD(DUK_DDDPRINT("created native function object with flags: 0x%08lx, nargs=%ld",
-+	                     (unsigned long) obj->obj.hdr.h_flags, (long) obj->nargs));
-+
-+	tv_slot = thr->valstack_top;
-+	DUK_TVAL_SET_OBJECT(tv_slot, (duk_hobject *) obj);
-+	DUK_HOBJECT_INCREF(thr, obj);
-+	ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+	thr->valstack_top++;
-+
-+	/* default prototype (Note: 'obj' must be reachable) */
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
-+
-+	return ret;
-+
-+ api_error:
-+	DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+	return 0;  /* not reached */
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_int_t nargs) {
-+	duk_uint_t flags;
-+
-+	flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	        DUK_HOBJECT_FLAG_CONSTRUCTABLE |
-+	        DUK_HOBJECT_FLAG_NATIVEFUNCTION |
-+	        DUK_HOBJECT_FLAG_NEWENV |
-+	        DUK_HOBJECT_FLAG_STRICT |
-+	        DUK_HOBJECT_FLAG_NOTAIL |
-+	        DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC |
-+	        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
-+
-+	return duk__push_c_function_raw(ctx, func, nargs, flags);
-+}
-+
-+DUK_INTERNAL void duk_push_c_function_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs) {
-+	duk_uint_t flags;
-+
-+	flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	        DUK_HOBJECT_FLAG_CONSTRUCTABLE |
-+	        DUK_HOBJECT_FLAG_NATIVEFUNCTION |
-+	        DUK_HOBJECT_FLAG_NEWENV |
-+	        DUK_HOBJECT_FLAG_STRICT |
-+	        DUK_HOBJECT_FLAG_NOTAIL |
-+	        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
-+
-+	(void) duk__push_c_function_raw(ctx, func, nargs, flags);
-+}
-+
-+DUK_INTERNAL void duk_push_c_function_noconstruct_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs) {
-+	duk_uint_t flags;
-+
-+	flags = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	        DUK_HOBJECT_FLAG_NATIVEFUNCTION |
-+	        DUK_HOBJECT_FLAG_NEWENV |
-+	        DUK_HOBJECT_FLAG_STRICT |
-+	        DUK_HOBJECT_FLAG_NOTAIL |
-+	        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION);
-+
-+	(void) duk__push_c_function_raw(ctx, func, nargs, flags);
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_push_c_lightfunc(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_idx_t length, duk_int_t magic) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval tv_tmp;
-+	duk_small_uint_t lf_flags;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* check stack first */
-+	if (thr->valstack_top >= thr->valstack_end) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
-+	}
-+
-+	if (nargs >= DUK_LFUNC_NARGS_MIN && nargs <= DUK_LFUNC_NARGS_MAX) {
-+		/* as is */
-+	} else if (nargs == DUK_VARARGS) {
-+		nargs = DUK_LFUNC_NARGS_VARARGS;
-+	} else {
-+		goto api_error;
-+	}
-+	if (!(length >= DUK_LFUNC_LENGTH_MIN && length <= DUK_LFUNC_LENGTH_MAX)) {
-+		goto api_error;
-+	}
-+	if (!(magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX)) {
-+		goto api_error;
-+	}
-+
-+	lf_flags = DUK_LFUNC_FLAGS_PACK(magic, length, nargs);
-+	DUK_TVAL_SET_LIGHTFUNC(&tv_tmp, func, lf_flags);
-+	duk_push_tval(ctx, &tv_tmp);  /* XXX: direct valstack write */
-+	DUK_ASSERT(thr->valstack_top != thr->valstack_bottom);
-+	return ((duk_idx_t) (thr->valstack_top - thr->valstack_bottom)) - 1;
-+
-+ api_error:
-+	DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+	return 0;  /* not reached */
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t ret;
-+	duk_hobject *proto;
-+#ifdef DUK_USE_AUGMENT_ERROR_CREATE
-+	duk_bool_t noblame_fileline;
-+#endif
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_UNREF(filename);
-+	DUK_UNREF(line);
-+
-+	/* Error code also packs a tracedata related flag. */
-+#ifdef DUK_USE_AUGMENT_ERROR_CREATE
-+	noblame_fileline = err_code & DUK_ERRCODE_FLAG_NOBLAME_FILELINE;
-+#endif
-+	err_code = err_code & (~DUK_ERRCODE_FLAG_NOBLAME_FILELINE);
-+
-+	/* error gets its 'name' from the prototype */
-+	proto = duk_error_prototype_from_code(thr, err_code);
-+	ret = duk_push_object_helper_proto(ctx,
-+	                                   DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                                   DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR),
-+	                                   proto);
-+
-+	/* ... and its 'message' from an instance property */
-+	if (fmt) {
-+		duk_push_vsprintf(ctx, fmt, ap);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC);
-+	} else {
-+		/* If no explicit message given, put error code into message field
-+		 * (as a number).  This is not fully in keeping with the Ecmascript
-+		 * error model because messages are supposed to be strings (Error
-+		 * constructors use ToString() on their argument).  However, it's
-+		 * probably more useful than having a separate 'code' property.
-+		 */
-+		duk_push_int(ctx, err_code);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC);
-+	}
-+
-+#if 0
-+	/* Disabled for now, not sure this is a useful property */
-+	duk_push_int(ctx, err_code);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CODE, DUK_PROPDESC_FLAGS_WC);
-+#endif
-+
-+	/* Creation time error augmentation */
-+#ifdef DUK_USE_AUGMENT_ERROR_CREATE
-+	/* filename may be NULL in which case file/line is not recorded */
-+	duk_err_augment_error_create(thr, thr, filename, line, noblame_fileline);  /* may throw an error */
-+#endif
-+
-+	return ret;
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_push_error_object_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...) {
-+	va_list ap;
-+	duk_idx_t ret;
-+
-+	va_start(ap, fmt);
-+	ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
-+	va_end(ap);
-+	return ret;
-+}
-+
-+#if !defined(DUK_USE_VARIADIC_MACROS)
-+DUK_EXTERNAL duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...) {
-+	const char *filename = duk_api_global_filename;
-+	duk_int_t line = duk_api_global_line;
-+	va_list ap;
-+	duk_idx_t ret;
-+
-+	duk_api_global_filename = NULL;
-+	duk_api_global_line = 0;
-+	va_start(ap, fmt);
-+	ret = duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
-+	va_end(ap);
-+	return ret;
-+}
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+DUK_EXTERNAL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv_slot;
-+	duk_hbuffer *h;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* check stack first */
-+	if (thr->valstack_top >= thr->valstack_end) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_PUSH_BEYOND_ALLOC_STACK);
-+	}
-+
-+	/* Check for maximum buffer length. */
-+	if (size > DUK_HBUFFER_MAX_BYTELEN) {
-+		DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_BUFFER_TOO_LONG);
-+	}
-+
-+	h = duk_hbuffer_alloc(thr->heap, size, flags);
-+	if (!h) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_BUFFER_ALLOC_FAILED);
-+	}
-+
-+	tv_slot = thr->valstack_top;
-+	DUK_TVAL_SET_BUFFER(tv_slot, h);
-+	DUK_HBUFFER_INCREF(thr, h);
-+	thr->valstack_top++;
-+
-+	return DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);
-+}
-+
-+DUK_EXTERNAL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t ret;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	ret = (duk_idx_t) (thr->valstack_top - thr->valstack_bottom);
-+
-+	if (ptr == NULL) {
-+		goto push_undefined;
-+	}
-+
-+	switch (DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) ptr)) {
-+	case DUK_HTYPE_STRING:
-+		duk_push_hstring(ctx, (duk_hstring *) ptr);
-+		break;
-+	case DUK_HTYPE_OBJECT:
-+		duk_push_hobject(ctx, (duk_hobject *) ptr);
-+		break;
-+	case DUK_HTYPE_BUFFER:
-+		duk_push_hbuffer(ctx, (duk_hbuffer *) ptr);
-+		break;
-+	default:
-+		goto push_undefined;
-+	}
-+	return ret;
-+
-+ push_undefined:
-+	duk_push_undefined(ctx);
-+	return ret;
-+}
-+
-+DUK_INTERNAL duk_idx_t duk_push_object_internal(duk_context *ctx) {
-+	return duk_push_object_helper(ctx,
-+	                              DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                              DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-+	                              -1);  /* no prototype */
-+}
-+
-+DUK_INTERNAL void duk_push_hstring(duk_context *ctx, duk_hstring *h) {
-+	duk_tval tv;
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(h != NULL);
-+	DUK_TVAL_SET_STRING(&tv, h);
-+	duk_push_tval(ctx, &tv);
-+}
-+
-+DUK_INTERNAL void duk_push_hstring_stridx(duk_context *ctx, duk_small_int_t stridx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	DUK_ASSERT(stridx >= 0 && stridx < DUK_HEAP_NUM_STRINGS);
-+	duk_push_hstring(ctx, DUK_HTHREAD_GET_STRING(thr, stridx));
-+}
-+
-+DUK_INTERNAL void duk_push_hobject(duk_context *ctx, duk_hobject *h) {
-+	duk_tval tv;
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(h != NULL);
-+	DUK_TVAL_SET_OBJECT(&tv, h);
-+	duk_push_tval(ctx, &tv);
-+}
-+
-+DUK_INTERNAL void duk_push_hbuffer(duk_context *ctx, duk_hbuffer *h) {
-+	duk_tval tv;
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(h != NULL);
-+	DUK_TVAL_SET_BUFFER(&tv, h);
-+	duk_push_tval(ctx, &tv);
-+}
-+
-+DUK_INTERNAL void duk_push_hobject_bidx(duk_context *ctx, duk_small_int_t builtin_idx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(builtin_idx >= 0 && builtin_idx < DUK_NUM_BUILTINS);
-+	DUK_ASSERT(thr->builtins[builtin_idx] != NULL);
-+	duk_push_hobject(ctx, thr->builtins[builtin_idx]);
-+}
-+
-+/*
-+ *  Poppers
-+ */
-+
-+DUK_EXTERNAL void duk_pop_n(duk_context *ctx, duk_idx_t count) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	DUK_ASSERT(ctx != NULL);
-+
-+	if (count < 0) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT);
-+		return;
-+	}
-+
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	if ((duk_size_t) (thr->valstack_top - thr->valstack_bottom) < (duk_size_t) count) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_POP_TOO_MANY);
-+	}
-+
-+	/*
-+	 *  Must be very careful here, every DECREF may cause reallocation
-+	 *  of our valstack.
-+	 */
-+
-+	/* XXX: inlined DECREF macro would be nice here: no NULL check,
-+	 * refzero queueing but no refzero algorithm run (= no pointer
-+	 * instability), inline code.
-+	 */
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	while (count > 0) {
-+		duk_tval tv_tmp;
-+		duk_tval *tv;
-+
-+		tv = --thr->valstack_top;  /* tv points to element just below prev top */
-+		DUK_ASSERT(tv >= thr->valstack_bottom);
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+		DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+		count--;
-+	}
-+#else
-+	while (count > 0) {
-+		duk_tval *tv;
-+
-+		tv = --thr->valstack_top;
-+		DUK_ASSERT(tv >= thr->valstack_bottom);
-+		DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+		count--;
-+	}
-+#endif
-+
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+}
-+
-+DUK_EXTERNAL void duk_pop(duk_context *ctx) {
-+	duk_pop_n(ctx, 1);
-+}
-+
-+DUK_EXTERNAL void duk_pop_2(duk_context *ctx) {
-+	duk_pop_n(ctx, 2);
-+}
-+
-+DUK_EXTERNAL void duk_pop_3(duk_context *ctx) {
-+	duk_pop_n(ctx, 3);
-+}
-+
-+/*
-+ *  Error throwing
-+ */
-+
-+DUK_EXTERNAL void duk_throw(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+
-+	if (thr->valstack_top == thr->valstack_bottom) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+	}
-+
-+	/* Errors are augmented when they are created, not when they are
-+	 * thrown or re-thrown.  The current error handler, however, runs
-+	 * just before an error is thrown.
-+	 */
-+
-+#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-+	DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (before throw augment)", (duk_tval *) duk_get_tval(ctx, -1)));
-+	duk_err_augment_error_throw(thr);
-+#endif
-+	DUK_DDD(DUK_DDDPRINT("THROW ERROR (API): %!dT (after throw augment)", (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
-+
-+	/* thr->heap->lj.jmpbuf_ptr is checked by duk_err_longjmp() so we don't
-+	 * need to check that here.  If the value is NULL, a panic occurs because
-+	 * we can't return.
-+	 */
-+
-+	duk_err_longjmp(thr);
-+	DUK_UNREACHABLE();
-+}
-+
-+DUK_EXTERNAL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(thr->heap->fatal_func != NULL);
-+
-+	DUK_D(DUK_DPRINT("fatal error occurred, code %ld, message %s",
-+	                 (long) err_code, (const char *) err_msg));
-+
-+	/* fatal_func should be noreturn, but noreturn declarations on function
-+	 * pointers has a very spotty support apparently so it's not currently
-+	 * done.
-+	 */
-+	thr->heap->fatal_func(ctx, err_code, err_msg);
-+
-+	DUK_PANIC(DUK_ERR_API_ERROR, "fatal handler returned");
-+}
-+
-+DUK_EXTERNAL void duk_error_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap) {
-+	duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
-+	duk_throw(ctx);
-+}
-+
-+DUK_EXTERNAL void duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...) {
-+	va_list ap;
-+	va_start(ap, fmt);
-+	duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
-+	va_end(ap);
-+	duk_throw(ctx);
-+}
-+
-+#if !defined(DUK_USE_VARIADIC_MACROS)
-+DUK_EXTERNAL void duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...) {
-+	const char *filename;
-+	duk_int_t line;
-+	va_list ap;
-+
-+	filename = duk_api_global_filename;
-+	line = duk_api_global_line;
-+	duk_api_global_filename = NULL;
-+	duk_api_global_line = 0;
-+
-+	va_start(ap, fmt);
-+	duk_push_error_object_va_raw(ctx, err_code, filename, line, fmt, ap);
-+	va_end(ap);
-+	duk_throw(ctx);
-+}
-+#endif  /* DUK_USE_VARIADIC_MACROS */
-+
-+/*
-+ *  Comparison
-+ */
-+
-+DUK_EXTERNAL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv1, *tv2;
-+
-+	tv1 = duk_get_tval(ctx, index1);
-+	if (!tv1) {
-+		return 0;
-+	}
-+	tv2 = duk_get_tval(ctx, index2);
-+	if (!tv2) {
-+		return 0;
-+	}
-+
-+	/* Coercion may be needed, the helper handles that by pushing the
-+	 * tagged values to the stack.
-+	 */
-+	return duk_js_equals(thr, tv1, tv2);
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2) {
-+	duk_tval *tv1, *tv2;
-+
-+	tv1 = duk_get_tval(ctx, index1);
-+	if (!tv1) {
-+		return 0;
-+	}
-+	tv2 = duk_get_tval(ctx, index2);
-+	if (!tv2) {
-+		return 0;
-+	}
-+
-+	/* No coercions or other side effects, so safe */
-+	return duk_js_strict_equals(tv1, tv2);
-+}
-+
-+/*
-+ *  Lightfunc
-+ */
-+
-+DUK_INTERNAL void duk_push_lightfunc_name(duk_context *ctx, duk_tval *tv) {
-+	duk_c_function func;
-+
-+	DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv));
-+
-+	/* Lightfunc name, includes Duktape/C native function pointer, which
-+	 * can often be used to locate the function from a symbol table.
-+	 * The name also includes the 16-bit duk_tval flags field because it
-+	 * includes the magic value.  Because a single native function often
-+	 * provides different functionality depending on the magic value, it
-+	 * seems reasonably to include it in the name.
-+	 *
-+	 * On the other hand, a complicated name increases string table
-+	 * pressure in low memory environments (but only when function name
-+	 * is accessed).
-+	 */
-+
-+	func = DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv);
-+	duk_push_sprintf(ctx, "light_");
-+	duk_push_string_funcptr(ctx, (duk_uint8_t *) &func, sizeof(func));
-+	duk_push_sprintf(ctx, "_%04x", (unsigned int) DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv));
-+	duk_concat(ctx, 3);
-+}
-+
-+DUK_INTERNAL void duk_push_lightfunc_tostring(duk_context *ctx, duk_tval *tv) {
-+	DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv));
-+
-+	duk_push_string(ctx, "function ");
-+	duk_push_lightfunc_name(ctx, tv);
-+	duk_push_string(ctx, "() {/* light */}");
-+	duk_concat(ctx, 3);
-+}
-+
-+/*
-+ *  Function pointers
-+ *
-+ *  Printing function pointers is non-portable, so we do that by hex printing
-+ *  bytes from memory.
-+ */
-+
-+DUK_INTERNAL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz) {
-+	duk_uint8_t buf[32 * 2];
-+	duk_uint8_t *p, *q;
-+	duk_small_uint_t i;
-+	duk_small_uint_t t;
-+
-+	DUK_ASSERT(sz <= 32);  /* sanity limit for function pointer size */
-+
-+	p = buf;
-+#if defined(DUK_USE_INTEGER_LE)
-+	q = ptr + sz;
-+#else
-+	q = ptr;
-+#endif
-+	for (i = 0; i < sz; i++) {
-+#if defined(DUK_USE_INTEGER_LE)
-+		t = *(--q);
-+#else
-+		t = *(q++);
-+#endif
-+		*p++ = duk_lc_digits[t >> 4];
-+		*p++ = duk_lc_digits[t & 0x0f];
-+	}
-+
-+	duk_push_lstring(ctx, (const char *) buf, sz * 2);
-+}
-+
-+#undef DUK__CHECK_SPACE
-+#line 1 "duk_api_string.c"
-+/*
-+ *  String manipulation
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_LOCAL void duk__concat_and_join_helper(duk_context *ctx, duk_idx_t count_in, duk_bool_t is_join) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_uint_t count;
-+	duk_uint_t i;
-+	duk_size_t idx;
-+	duk_size_t len;
-+	duk_hstring *h;
-+	duk_uint8_t *buf;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	if (DUK_UNLIKELY(count_in <= 0)) {
-+		if (count_in < 0) {
-+			DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_COUNT);
-+			return;
-+		}
-+		DUK_ASSERT(count_in == 0);
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
-+		return;
-+	}
-+	count = (duk_uint_t) count_in;
-+
-+	if (is_join) {
-+		duk_size_t t1, t2, limit;
-+		h = duk_to_hstring(ctx, -((duk_idx_t) count) - 1);
-+		DUK_ASSERT(h != NULL);
-+
-+		/* A bit tricky overflow test, see doc/code-issues.txt. */
-+		t1 = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h);
-+		t2 = (duk_size_t) (count - 1);
-+		limit = (duk_size_t) DUK_HSTRING_MAX_BYTELEN;
-+		if (DUK_UNLIKELY(t2 != 0 && t1 > limit / t2)) {
-+			/* Combined size of separators already overflows */
-+			goto error_overflow;
-+		}
-+		len = (duk_size_t) (t1 * t2);
-+	} else {
-+		len = (duk_size_t) 0;
-+	}
-+
-+	for (i = count; i >= 1; i--) {
-+		duk_size_t new_len;
-+		duk_to_string(ctx, -((duk_idx_t) i));
-+		h = duk_require_hstring(ctx, -((duk_idx_t) i));
-+		new_len = len + (duk_size_t) DUK_HSTRING_GET_BYTELEN(h);
-+
-+		/* Impose a string maximum length, need to handle overflow
-+		 * correctly.
-+		 */
-+		if (new_len < len ||  /* wrapped */
-+		    new_len > (duk_size_t) DUK_HSTRING_MAX_BYTELEN) {
-+			goto error_overflow;
-+		}
-+		len = new_len;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("join/concat %lu strings, total length %lu bytes",
-+	                     (unsigned long) count, (unsigned long) len));
-+
-+	/* use stack allocated buffer to ensure reachability in errors (e.g. intern error) */
-+	buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, len);
-+	DUK_ASSERT(buf != NULL);
-+
-+	/* [... (sep) str1 str2 ... strN buf] */
-+
-+	idx = 0;
-+	for (i = count; i >= 1; i--) {
-+		if (is_join && i != count) {
-+			h = duk_require_hstring(ctx, -((duk_idx_t) count) - 2);  /* extra -1 for buffer */
-+			DUK_MEMCPY(buf + idx, DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h));
-+			idx += DUK_HSTRING_GET_BYTELEN(h);
-+		}
-+		h = duk_require_hstring(ctx, -((duk_idx_t) i) - 1);  /* extra -1 for buffer */
-+		DUK_MEMCPY(buf + idx, DUK_HSTRING_GET_DATA(h), DUK_HSTRING_GET_BYTELEN(h));
-+		idx += DUK_HSTRING_GET_BYTELEN(h);
-+	}
-+
-+	DUK_ASSERT(idx == len);
-+
-+	/* [... (sep) str1 str2 ... strN buf] */
-+
-+	/* get rid of the strings early to minimize memory use before intern */
-+
-+	if (is_join) {
-+		duk_replace(ctx, -((duk_idx_t) count) - 2);  /* overwrite sep */
-+		duk_pop_n(ctx, count);
-+	} else {
-+		duk_replace(ctx, -((duk_idx_t) count) - 1);  /* overwrite str1 */
-+		duk_pop_n(ctx, count-1);
-+	}
-+
-+	/* [... buf] */
-+
-+	(void) duk_to_string(ctx, -1);
-+
-+	/* [... res] */
-+	return;
-+
-+ error_overflow:
-+	DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_CONCAT_RESULT_TOO_LONG);
-+}
-+
-+DUK_EXTERNAL void duk_concat(duk_context *ctx, duk_idx_t count) {
-+	duk__concat_and_join_helper(ctx, count, 0 /*is_join*/);
-+}
-+
-+DUK_EXTERNAL void duk_join(duk_context *ctx, duk_idx_t count) {
-+	duk__concat_and_join_helper(ctx, count, 1 /*is_join*/);
-+}
-+
-+/* XXX: could map/decode be unified with duk_unicode_support.c code?
-+ * Case conversion needs also the character surroundings though.
-+ */
-+
-+DUK_EXTERNAL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_input;
-+	const duk_uint8_t *p, *p_start, *p_end;
-+	duk_codepoint_t cp;
-+
-+	h_input = duk_require_hstring(ctx, index);
-+	DUK_ASSERT(h_input != NULL);
-+
-+	p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
-+	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
-+	p = p_start;
-+
-+	for (;;) {
-+		if (p >= p_end) {
-+			break;
-+		}
-+		cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
-+		callback(udata, cp);
-+	}
-+}
-+
-+DUK_EXTERNAL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_input;
-+	duk_hbuffer_dynamic *h_buf;
-+	const duk_uint8_t *p, *p_start, *p_end;
-+	duk_codepoint_t cp;
-+
-+	index = duk_normalize_index(ctx, index);
-+
-+	h_input = duk_require_hstring(ctx, index);
-+	DUK_ASSERT(h_input != NULL);
-+
-+	/* XXX: should init with a spare of at least h_input->blen? */
-+	duk_push_dynamic_buffer(ctx, 0);
-+	h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(h_buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf));
-+
-+	p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
-+	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
-+	p = p_start;
-+
-+	for (;;) {
-+		if (p >= p_end) {
-+			break;
-+		}
-+		cp = (int) duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
-+		cp = callback(udata, cp);
-+		duk_hbuffer_append_xutf8(thr, h_buf, cp);
-+	}
-+
-+	duk_to_string(ctx, -1);  /* invalidates h_buf pointer */
-+	duk_replace(ctx, index);
-+}
-+
-+DUK_EXTERNAL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_offset, duk_size_t end_offset) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h;
-+	duk_hstring *res;
-+	duk_size_t start_byte_offset;
-+	duk_size_t end_byte_offset;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	h = duk_require_hstring(ctx, index);
-+	DUK_ASSERT(h != NULL);
-+
-+	if (end_offset >= DUK_HSTRING_GET_CHARLEN(h)) {
-+		end_offset = DUK_HSTRING_GET_CHARLEN(h);
-+	}
-+	if (start_offset > end_offset) {
-+		start_offset = end_offset;
-+	}
-+
-+	DUK_ASSERT_DISABLE(start_offset >= 0);
-+	DUK_ASSERT(start_offset <= end_offset && start_offset <= DUK_HSTRING_GET_CHARLEN(h));
-+	DUK_ASSERT_DISABLE(end_offset >= 0);
-+	DUK_ASSERT(end_offset >= start_offset && end_offset <= DUK_HSTRING_GET_CHARLEN(h));
-+
-+	/* guaranteed by string limits */
-+	DUK_ASSERT(start_offset <= DUK_UINT32_MAX);
-+	DUK_ASSERT(end_offset <= DUK_UINT32_MAX);
-+
-+	start_byte_offset = (duk_size_t) duk_heap_strcache_offset_char2byte(thr, h, (duk_uint_fast32_t) start_offset);
-+	end_byte_offset = (duk_size_t) duk_heap_strcache_offset_char2byte(thr, h, (duk_uint_fast32_t) end_offset);
-+
-+	DUK_ASSERT(end_byte_offset >= start_byte_offset);
-+	DUK_ASSERT(end_byte_offset - start_byte_offset <= DUK_UINT32_MAX);  /* guaranteed by string limits */
-+
-+	/* no size check is necessary */
-+	res = duk_heap_string_intern_checked(thr,
-+	                                     DUK_HSTRING_GET_DATA(h) + start_byte_offset,
-+	                                     (duk_uint32_t) (end_byte_offset - start_byte_offset));
-+
-+	duk_push_hstring(ctx, res);
-+	duk_replace(ctx, index);
-+}
-+
-+/* XXX: this is quite clunky.  Add Unicode helpers to scan backwards and
-+ * forwards with a callback to process codepoints?
-+ */
-+DUK_EXTERNAL void duk_trim(duk_context *ctx, duk_idx_t index) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h;
-+	const duk_uint8_t *p, *p_start, *p_end, *p_tmp1, *p_tmp2;  /* pointers for scanning */
-+	const duk_uint8_t *q_start, *q_end;  /* start (incl) and end (excl) of trimmed part */
-+	duk_codepoint_t cp;
-+
-+	index = duk_require_normalize_index(ctx, index);
-+	h = duk_require_hstring(ctx, index);
-+	DUK_ASSERT(h != NULL);
-+
-+	p_start = DUK_HSTRING_GET_DATA(h);
-+	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h);
-+
-+	p = p_start;
-+	while (p < p_end) {
-+		p_tmp1 = p;
-+		cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp1, p_start, p_end);
-+		if (!(duk_unicode_is_whitespace(cp) || duk_unicode_is_line_terminator(cp))) {
-+			break;
-+		}
-+		p = p_tmp1;
-+	}
-+	q_start = p;
-+	if (p == p_end) {
-+		/* entire string is whitespace */
-+		q_end = p;
-+		goto scan_done;
-+	}
-+
-+	p = p_end;
-+	while (p > p_start) {
-+		p_tmp1 = p;
-+		while (p > p_start) {
-+			p--;
-+			if (((*p) & 0xc0) != 0x80) {
-+				break;
-+			}
-+		}
-+		p_tmp2 = p;
-+
-+		cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &p_tmp2, p_start, p_end);
-+		if (!(duk_unicode_is_whitespace(cp) || duk_unicode_is_line_terminator(cp))) {
-+			p = p_tmp1;
-+			break;
-+		}
-+	}
-+	q_end = p;
-+
-+ scan_done:
-+	/* This may happen when forward and backward scanning disagree
-+	 * (possible for non-extended-UTF-8 strings).
-+	 */
-+	if (q_end < q_start) {
-+		q_end = q_start;
-+	}
-+
-+	DUK_ASSERT(q_start >= p_start && q_start <= p_end);
-+	DUK_ASSERT(q_end >= p_start && q_end <= p_end);
-+	DUK_ASSERT(q_end >= q_start);
-+
-+	DUK_DDD(DUK_DDDPRINT("trim: p_start=%p, p_end=%p, q_start=%p, q_end=%p",
-+	                     (void *) p_start, (void *) p_end, (void *) q_start, (void *) q_end));
-+
-+	if (q_start == p_start && q_end == p_end) {
-+		DUK_DDD(DUK_DDDPRINT("nothing was trimmed: avoid interning (hashing etc)"));
-+		return;
-+	}
-+
-+	duk_push_lstring(ctx, (const char *) q_start, (duk_size_t) (q_end - q_start));
-+	duk_replace(ctx, index);
-+}
-+
-+DUK_EXTERNAL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h;
-+	duk_ucodepoint_t cp;
-+
-+	h = duk_require_hstring(ctx, index);
-+	DUK_ASSERT(h != NULL);
-+
-+	DUK_ASSERT_DISABLE(char_offset >= 0);  /* always true, arg is unsigned */
-+	if (char_offset >= DUK_HSTRING_GET_CHARLEN(h)) {
-+		return 0;
-+	}
-+
-+	DUK_ASSERT(char_offset <= DUK_UINT_MAX);  /* guaranteed by string limits */
-+	cp = duk_hstring_char_code_at_raw(thr, h, (duk_uint_t) char_offset);
-+	return (duk_codepoint_t) cp;
-+}
-+#line 1 "duk_api_var.c"
-+/*
-+ *  Variable access
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_EXTERNAL void duk_get_var(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_activation *act;
-+	duk_hstring *h_varname;
-+	duk_small_int_t throw_flag = 1;  /* always throw ReferenceError for unresolvable */
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	h_varname = duk_require_hstring(ctx, -1);  /* XXX: tostring? */
-+	DUK_ASSERT(h_varname != NULL);
-+
-+	act = duk_hthread_get_current_activation(thr);
-+	if (act) {
-+		(void) duk_js_getvar_activation(thr, act, h_varname, throw_flag);  /* -> [ ... varname val this ] */
-+	} else {
-+		/* Outside any activation -> look up from global. */
-+		DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL_ENV] != NULL);
-+		(void) duk_js_getvar_envrec(thr, thr->builtins[DUK_BIDX_GLOBAL_ENV], h_varname, throw_flag);
-+	}
-+
-+	/* [ ... varname val this ]  (because throw_flag == 1, always resolved) */
-+
-+	duk_pop(ctx);
-+	duk_remove(ctx, -2);
-+
-+	/* [ ... val ] */
-+
-+	/* Return value would be pointless: because throw_flag==1, we always
-+	 * throw if the identifier doesn't resolve.
-+	 */
-+	return;
-+}
-+
-+DUK_EXTERNAL void duk_put_var(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_activation *act;
-+	duk_hstring *h_varname;
-+	duk_tval *tv_val;
-+	duk_small_int_t throw_flag;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	h_varname = duk_require_hstring(ctx, -2);  /* XXX: tostring? */
-+	DUK_ASSERT(h_varname != NULL);
-+
-+	tv_val = duk_require_tval(ctx, -1);
-+
-+	throw_flag = duk_is_strict_call(ctx);
-+
-+	act = duk_hthread_get_current_activation(thr);
-+	if (act) {
-+		duk_js_putvar_activation(thr, act, h_varname, tv_val, throw_flag);  /* -> [ ... varname val this ] */
-+	} else {
-+		/* Outside any activation -> put to global. */
-+		DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL_ENV] != NULL);
-+		duk_js_putvar_envrec(thr, thr->builtins[DUK_BIDX_GLOBAL_ENV], h_varname, tv_val, throw_flag);
-+	}
-+
-+	/* [ ... varname val ] */
-+
-+	duk_pop_2(ctx);
-+
-+	/* [ ... ] */
-+
-+	return;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_del_var(duk_context *ctx) {
-+	DUK_ERROR((duk_hthread *) ctx, DUK_ERR_UNIMPLEMENTED_ERROR, DUK_STR_UNIMPLEMENTED);
-+	return 0;
-+}
-+
-+DUK_EXTERNAL duk_bool_t duk_has_var(duk_context *ctx) {
-+	DUK_ERROR((duk_hthread *) ctx, DUK_ERR_UNIMPLEMENTED_ERROR, DUK_STR_UNIMPLEMENTED);
-+	return 0;
-+}
-+#line 1 "duk_bi_array.c"
-+/*
-+ *  Array built-ins
-+ *
-+ *  Note that most Array built-ins are intentionally generic and work even
-+ *  when the 'this' binding is not an Array instance.  To ensure this,
-+ *  Array algorithms do not assume "magical" Array behavior for the "length"
-+ *  property, for instance.
-+ *
-+ *  XXX: the "Throw" flag should be set for (almost?) all [[Put]] and
-+ *  [[Delete]] operations, but it's currently false throughout.  Go through
-+ *  all put/delete cases and check throw flag use.  Need a new API primitive
-+ *  which allows throws flag to be specified.
-+ *
-+ *  XXX: array lengths above 2G won't work reliably.  There are many places
-+ *  where one needs a full signed 32-bit range ([-0xffffffff, 0xffffffff],
-+ *  i.e. -33- bits).  Although array 'length' cannot be written to be outside
-+ *  the unsigned 32-bit range (E5.1 Section 15.4.5.1 throws a RangeError if so)
-+ *  some intermediate values may be above 0xffffffff and this may not be always
-+ *  correctly handled now (duk_uint32_t is not enough for all algorithms).
-+ *
-+ *  For instance, push() can legitimately write entries beyond length 0xffffffff
-+ *  and cause a RangeError only at the end.  To do this properly, the current
-+ *  push() implementation tracks the array index using a 'double' instead of a
-+ *  duk_uint32_t (which is somewhat awkward).  See test-bi-array-push-maxlen.js.
-+ *
-+ *  On using "put" vs. "def" prop
-+ *  =============================
-+ *
-+ *  Code below must be careful to use the appropriate primitive as it matters
-+ *  for compliance.  When using "put" there may be inherited properties in
-+ *  Array.prototype which cause side effects when values are written.  When
-+ *  using "define" there are no such side effects, and many test262 test cases
-+ *  check for this (for real world code, such side effects are very rare).
-+ *  Both "put" and "define" are used in the E5.1 specification; as a rule,
-+ *  "put" is used when modifying an existing array (or a non-array 'this'
-+ *  binding) and "define" for setting values into a fresh result array.
-+ *
-+ *  Also note that Array instance 'length' should be writable, but not
-+ *  enumerable and definitely not configurable: even Duktape code internally
-+ *  assumes that an Array instance will always have a 'length' property.
-+ *  Preventing deletion of the property is critical.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* Perform an intermediate join when this many elements have been pushed
-+ * on the value stack.
-+ */
-+#define  DUK__ARRAY_MID_JOIN_LIMIT  4096
-+
-+/* Shared entry code for many Array built-ins.  Note that length is left
-+ * on stack (it could be popped, but that's not necessary).
-+ */
-+DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32(duk_context *ctx) {
-+	duk_uint32_t len;
-+
-+	(void) duk_push_this_coercible_to_object(ctx);
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH);
-+	len = duk_to_uint32(ctx, -1);
-+
-+	/* -> [ ... ToObject(this) ToUint32(length) ] */
-+	return len;
-+}
-+
-+DUK_LOCAL duk_uint32_t duk__push_this_obj_len_u32_limited(duk_context *ctx) {
-+	/* Range limited to [0, 0x7fffffff] range, i.e. range that can be
-+	 * represented with duk_int32_t.  Use this when the method doesn't
-+	 * handle the full 32-bit unsigned range correctly.
-+	 */
-+	duk_uint32_t ret = duk__push_this_obj_len_u32(ctx);
-+	if (DUK_UNLIKELY(ret >= 0x80000000UL)) {
-+		DUK_ERROR((duk_hthread *) ctx, DUK_ERR_INTERNAL_ERROR, DUK_STR_ARRAY_LENGTH_OVER_2G);
-+	}
-+	return ret;
-+}
-+
-+/*
-+ *  Constructor
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_constructor(duk_context *ctx) {
-+	duk_idx_t nargs;
-+	duk_double_t d;
-+	duk_uint32_t len;
-+	duk_idx_t i;
-+
-+	nargs = duk_get_top(ctx);
-+	duk_push_array(ctx);
-+
-+	if (nargs == 1 && duk_is_number(ctx, 0)) {
-+		/* XXX: expensive check (also shared elsewhere - so add a shared internal API call?) */
-+		d = duk_get_number(ctx, 0);
-+		len = duk_to_uint32(ctx, 0);
-+		if (((duk_double_t) len) != d) {
-+			return DUK_RET_RANGE_ERROR;
-+		}
-+
-+		/* XXX: if 'len' is low, may want to ensure array part is kept:
-+		 * the caller is likely to want a dense array.
-+		 */
-+		duk_push_u32(ctx, len);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);  /* [ ToUint32(len) array ToUint32(len) ] -> [ ToUint32(len) array ] */
-+		return 1;
-+	}
-+
-+	/* XXX: optimize by creating array into correct size directly, and
-+	 * operating on the array part directly; values can be memcpy()'d from
-+	 * value stack directly as long as refcounts are increased.
-+	 */
-+	for (i = 0; i < nargs; i++) {
-+		duk_dup(ctx, i);
-+		duk_xdef_prop_index_wec(ctx, -2, (duk_uarridx_t) i);
-+	}
-+
-+	duk_push_u32(ctx, (duk_uint32_t) nargs);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
-+	return 1;
-+}
-+
-+/*
-+ *  isArray()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_constructor_is_array(duk_context *ctx) {
-+	duk_hobject *h;
-+
-+	h = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_ARRAY);
-+	duk_push_boolean(ctx, (h != NULL));
-+	return 1;
-+}
-+
-+/*
-+ *  toString()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_to_string(duk_context *ctx) {
-+	(void) duk_push_this_coercible_to_object(ctx);
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_JOIN);
-+
-+	/* [ ... this func ] */
-+	if (!duk_is_callable(ctx, -1)) {
-+		/* Fall back to the initial (original) Object.toString().  We don't
-+		 * currently have pointers to the built-in functions, only the top
-+		 * level global objects (like "Array") so this is now done in a bit
-+		 * of a hacky manner.  It would be cleaner to push the (original)
-+		 * function and use duk_call_method().
-+		 */
-+
-+		/* XXX: 'this' will be ToObject() coerced twice, which is incorrect
-+		 * but should have no visible side effects.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("this.join is not callable, fall back to (original) Object.toString"));
-+		duk_set_top(ctx, 0);
-+		return duk_bi_object_prototype_to_string(ctx);  /* has access to 'this' binding */
-+	}
-+
-+	/* [ ... this func ] */
-+
-+	duk_insert(ctx, -2);
-+
-+	/* [ ... func this ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("calling: func=%!iT, this=%!iT",
-+	                     (duk_tval *) duk_get_tval(ctx, -2),
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+	duk_call_method(ctx, 0);
-+
-+	return 1;
-+}
-+
-+/*
-+ *  concat()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_concat(duk_context *ctx) {
-+	duk_idx_t i, n;
-+	duk_uarridx_t idx, idx_last;
-+	duk_uarridx_t j, len;
-+	duk_hobject *h;
-+
-+	/* XXX: the insert here is a bit expensive if there are a lot of items.
-+	 * It could also be special cased in the outermost for loop quite easily
-+	 * (as the element is dup()'d anyway).
-+	 */
-+
-+	(void) duk_push_this_coercible_to_object(ctx);
-+	duk_insert(ctx, 0);
-+	n = duk_get_top(ctx);
-+	duk_push_array(ctx);  /* -> [ ToObject(this) item1 ... itemN arr ] */
-+
-+	/* NOTE: The Array special behaviors are NOT invoked by duk_xdef_prop_index()
-+	 * (which differs from the official algorithm).  If no error is thrown, this
-+	 * doesn't matter as the length is updated at the end.  However, if an error
-+	 * is thrown, the length will be unset.  That shouldn't matter because the
-+	 * caller won't get a reference to the intermediate value.
-+	 */
-+
-+	idx = 0;
-+	idx_last = 0;
-+	for (i = 0; i < n; i++) {
-+		DUK_ASSERT_TOP(ctx, n + 1);
-+
-+		/* [ ToObject(this) item1 ... itemN arr ] */
-+
-+		duk_dup(ctx, i);
-+		h = duk_get_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_ARRAY);
-+		if (!h) {
-+			duk_xdef_prop_index_wec(ctx, -2, idx++);
-+			idx_last = idx;
-+			continue;
-+		}
-+
-+		/* [ ToObject(this) item1 ... itemN arr item(i) ] */
-+
-+		/* XXX: an array can have length higher than 32 bits; this is not handled
-+		 * correctly now.
-+		 */
-+		len = (duk_uarridx_t) duk_get_length(ctx, -1);
-+		for (j = 0; j < len; j++) {
-+			if (duk_get_prop_index(ctx, -1, j)) {
-+				/* [ ToObject(this) item1 ... itemN arr item(i) item(i)[j] ] */
-+				duk_xdef_prop_index_wec(ctx, -3, idx++);
-+				idx_last = idx;
-+			} else {
-+				idx++;
-+				duk_pop(ctx);
-+#if defined(DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER)
-+				/* According to E5.1 Section 15.4.4.4 nonexistent trailing
-+				 * elements do not affect 'length' of the result.  Test262
-+				 * and other engines disagree, so update idx_last here too.
-+				 */
-+				idx_last = idx;
-+#else
-+				/* Strict standard behavior, ignore trailing elements for
-+				 * result 'length'.
-+				 */
-+#endif
-+			}
-+		}
-+		duk_pop(ctx);
-+	}
-+
-+	/* The E5.1 Section 15.4.4.4 algorithm doesn't set the length explicitly
-+	 * in the end, but because we're operating with an internal value which
-+	 * is known to be an array, this should be equivalent.
-+	 */
-+	duk_push_uarridx(ctx, idx_last);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
-+
-+	DUK_ASSERT_TOP(ctx, n + 1);
-+	return 1;
-+}
-+
-+/*
-+ *  join(), toLocaleString()
-+ *
-+ *  Note: checking valstack is necessary, but only in the per-element loop.
-+ *
-+ *  Note: the trivial approach of pushing all the elements on the value stack
-+ *  and then calling duk_join() fails when the array contains a large number
-+ *  of elements.  This problem can't be offloaded to duk_join() because the
-+ *  elements to join must be handled here and have special handling.  Current
-+ *  approach is to do intermediate joins with very large number of elements.
-+ *  There is no fancy handling; the prefix gets re-joined multiple times.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_join_shared(duk_context *ctx) {
-+	duk_uint32_t len, count;
-+	duk_uint32_t idx;
-+	duk_small_int_t to_locale_string = duk_get_current_magic(ctx);
-+	duk_idx_t valstack_required;
-+
-+	/* For join(), nargs is 1.  For toLocaleString(), nargs is 0 and
-+	 * setting the top essentially pushes an undefined to the stack,
-+	 * thus defaulting to a comma separator.
-+	 */
-+	duk_set_top(ctx, 1);
-+	if (duk_is_undefined(ctx, 0)) {
-+		duk_pop(ctx);
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_COMMA);
-+	} else {
-+		duk_to_string(ctx, 0);
-+	}
-+
-+	len = duk__push_this_obj_len_u32(ctx);
-+
-+	/* [ sep ToObject(this) len ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("sep=%!T, this=%!T, len=%lu",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 1),
-+	                     (unsigned long) len));
-+
-+	/* The extra (+4) is tight. */
-+	valstack_required = (len >= DUK__ARRAY_MID_JOIN_LIMIT ?
-+	                     DUK__ARRAY_MID_JOIN_LIMIT : len) + 4;
-+	duk_require_stack(ctx, valstack_required);
-+
-+	duk_dup(ctx, 0);
-+
-+	/* [ sep ToObject(this) len sep ] */
-+
-+	count = 0;
-+	idx = 0;
-+	for (;;) {
-+		if (count >= DUK__ARRAY_MID_JOIN_LIMIT ||   /* intermediate join to avoid valstack overflow */
-+		    idx >= len) { /* end of loop (careful with len==0) */
-+			/* [ sep ToObject(this) len sep str0 ... str(count-1) ] */
-+			DUK_DDD(DUK_DDDPRINT("mid/final join, count=%ld, idx=%ld, len=%ld",
-+			                     (long) count, (long) idx, (long) len));
-+			duk_join(ctx, (duk_idx_t) count);  /* -> [ sep ToObject(this) len str ] */
-+			duk_dup(ctx, 0);                   /* -> [ sep ToObject(this) len str sep ] */
-+			duk_insert(ctx, -2);               /* -> [ sep ToObject(this) len sep str ] */
-+			count = 1;
-+		}
-+		if (idx >= len) {
-+			/* if true, the stack already contains the final result */
-+			break;
-+		}
-+
-+		duk_get_prop_index(ctx, 1, (duk_uarridx_t) idx);
-+		if (duk_is_null_or_undefined(ctx, -1)) {
-+			duk_pop(ctx);
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
-+		} else {
-+			if (to_locale_string) {
-+				duk_to_object(ctx, -1);
-+				duk_get_prop_stridx(ctx, -1, DUK_STRIDX_TO_LOCALE_STRING);
-+				duk_insert(ctx, -2);  /* -> [ ... toLocaleString ToObject(val) ] */
-+				duk_call_method(ctx, 0);
-+				duk_to_string(ctx, -1);
-+			} else {
-+				duk_to_string(ctx, -1);
-+			}
-+		}
-+
-+		count++;
-+		idx++;
-+	}
-+
-+	/* [ sep ToObject(this) len sep result ] */
-+
-+	return 1;
-+}
-+
-+/*
-+ *  pop(), push()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_pop(duk_context *ctx) {
-+	duk_uint32_t len;
-+	duk_uint32_t idx;
-+
-+	DUK_ASSERT_TOP(ctx, 0);
-+	len = duk__push_this_obj_len_u32(ctx);
-+	if (len == 0) {
-+		duk_push_int(ctx, 0);
-+		duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
-+		return 0;
-+	}
-+	idx = len - 1;
-+
-+	duk_get_prop_index(ctx, 0, (duk_uarridx_t) idx);
-+	duk_del_prop_index(ctx, 0, (duk_uarridx_t) idx);
-+	duk_push_u32(ctx, idx);
-+	duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_push(duk_context *ctx) {
-+	/* Note: 'this' is not necessarily an Array object.  The push()
-+	 * algorithm is supposed to work for other kinds of objects too,
-+	 * so the algorithm has e.g. an explicit update for the 'length'
-+	 * property which is normally "magical" in arrays.
-+	 */
-+
-+	duk_uint32_t len;
-+	duk_idx_t i, n;
-+
-+	n = duk_get_top(ctx);
-+	len = duk__push_this_obj_len_u32(ctx);
-+
-+	/* [ arg1 ... argN obj length ] */
-+
-+	/* Technically Array.prototype.push() can create an Array with length
-+	 * longer than 2^32-1, i.e. outside the 32-bit range.  The final length
-+	 * is *not* wrapped to 32 bits in the specification.
-+	 *
-+	 * This implementation tracks length with a uint32 because it's much
-+	 * more practical.
-+	 *
-+	 * See: test-bi-array-push-maxlen.js.
-+	 */
-+
-+	if (len + (duk_uint32_t) n < len) {
-+		DUK_D(DUK_DPRINT("Array.prototype.push() would go beyond 32-bit length, throw"));
-+		return DUK_RET_RANGE_ERROR;
-+	}
-+
-+	for (i = 0; i < n; i++) {
-+		duk_dup(ctx, i);
-+		duk_put_prop_index(ctx, -3, len + i);
-+	}
-+	len += n;
-+
-+	duk_push_u32(ctx, len);
-+	duk_dup_top(ctx);
-+	duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH);
-+
-+	/* [ arg1 ... argN obj length new_length ] */
-+	return 1;
-+}
-+
-+/*
-+ *  sort()
-+ *
-+ *  Currently qsort with random pivot.  This is now really, really slow,
-+ *  because there is no fast path for array parts.
-+ *
-+ *  Signed indices are used because qsort() leaves and degenerate cases
-+ *  may use a negative offset.
-+ */
-+
-+DUK_LOCAL duk_small_int_t duk__array_sort_compare(duk_context *ctx, duk_int_t idx1, duk_int_t idx2) {
-+	duk_bool_t have1, have2;
-+	duk_bool_t undef1, undef2;
-+	duk_small_int_t ret;
-+	duk_idx_t idx_obj = 1;  /* fixed offsets in valstack */
-+	duk_idx_t idx_fn = 0;
-+	duk_hstring *h1, *h2;
-+
-+	/* Fast exit if indices are identical.  This is valid for a non-existent property,
-+	 * for an undefined value, and almost always for ToString() coerced comparison of
-+	 * arbitrary values (corner cases where this is not the case include e.g. a an
-+	 * object with varying ToString() coercion).
-+	 *
-+	 * The specification does not prohibit "caching" of values read from the array, so
-+	 * assuming equality for comparing an index with itself falls into the category of
-+	 * "caching".
-+	 *
-+	 * Also, compareFn may be inconsistent, so skipping a call to compareFn here may
-+	 * have an effect on the final result.  The specification does not require any
-+	 * specific behavior for inconsistent compare functions, so again, this fast path
-+	 * is OK.
-+	 */
-+
-+	if (idx1 == idx2) {
-+		DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld -> indices identical, quick exit",
-+		                     (long) idx1, (long) idx2));
-+		return 0;
-+	}
-+
-+	have1 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx1);
-+	have2 = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) idx2);
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__array_sort_compare: idx1=%ld, idx2=%ld, have1=%ld, have2=%ld, val1=%!T, val2=%!T",
-+	                     (long) idx1, (long) idx2, (long) have1, (long) have2,
-+	                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	if (have1) {
-+		if (have2) {
-+			;
-+		} else {
-+			ret = -1;
-+			goto pop_ret;
-+		}
-+	} else {
-+		if (have2) {
-+			ret = 1;
-+			goto pop_ret;
-+		} else {
-+			ret = 0;
-+			goto pop_ret;
-+		}
-+	}
-+
-+	undef1 = duk_is_undefined(ctx, -2);
-+	undef2 = duk_is_undefined(ctx, -1);
-+	if (undef1) {
-+		if (undef2) {
-+			ret = 0;
-+			goto pop_ret;
-+		} else {
-+			ret = 1;
-+			goto pop_ret;
-+		}
-+	} else {
-+		if (undef2) {
-+			ret = -1;
-+			goto pop_ret;
-+		} else {
-+			;
-+		}
-+	}
-+
-+	if (!duk_is_undefined(ctx, idx_fn)) {
-+		duk_double_t d;
-+
-+		/* no need to check callable; duk_call() will do that */
-+		duk_dup(ctx, idx_fn);    /* -> [ ... x y fn ] */
-+		duk_insert(ctx, -3);     /* -> [ ... fn x y ] */
-+		duk_call(ctx, 2);        /* -> [ ... res ] */
-+
-+		/* The specification is a bit vague what to do if the return
-+		 * value is not a number.  Other implementations seem to
-+		 * tolerate non-numbers but e.g. V8 won't apparently do a
-+		 * ToNumber().
-+		 */
-+
-+		/* XXX: best behavior for real world compatibility? */
-+
-+		d = duk_to_number(ctx, -1);
-+		if (d < 0.0) {
-+			ret = -1;
-+		} else if (d > 0.0) {
-+			ret = 1;
-+		} else {
-+			ret = 0;
-+		}
-+
-+		duk_pop(ctx);
-+		DUK_DDD(DUK_DDDPRINT("-> result %ld (from comparefn, after coercion)", (long) ret));
-+		return ret;
-+	}
-+
-+	/* string compare is the default (a bit oddly) */
-+
-+	h1 = duk_to_hstring(ctx, -2);
-+	h2 = duk_to_hstring(ctx, -1);
-+	DUK_ASSERT(h1 != NULL);
-+	DUK_ASSERT(h2 != NULL);
-+
-+	ret = duk_js_string_compare(h1, h2);  /* retval is directly usable */
-+	goto pop_ret;
-+
-+ pop_ret:
-+	duk_pop_2(ctx);
-+	DUK_DDD(DUK_DDDPRINT("-> result %ld", (long) ret));
-+	return ret;
-+}
-+
-+DUK_LOCAL void duk__array_sort_swap(duk_context *ctx, duk_int_t l, duk_int_t r) {
-+	duk_bool_t have_l, have_r;
-+	duk_idx_t idx_obj = 1;  /* fixed offset in valstack */
-+
-+	if (l == r) {
-+		return;
-+	}
-+
-+	/* swap elements; deal with non-existent elements correctly */
-+	have_l = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) l);
-+	have_r = duk_get_prop_index(ctx, idx_obj, (duk_uarridx_t) r);
-+
-+	if (have_r) {
-+		/* right exists, [[Put]] regardless whether or not left exists */
-+		duk_put_prop_index(ctx, idx_obj, (duk_uarridx_t) l);
-+	} else {
-+		duk_del_prop_index(ctx, idx_obj, (duk_uarridx_t) l);
-+		duk_pop(ctx);
-+	}
-+
-+	if (have_l) {
-+		duk_put_prop_index(ctx, idx_obj, (duk_uarridx_t) r);
-+	} else {
-+		duk_del_prop_index(ctx, idx_obj, (duk_uarridx_t) r);
-+		duk_pop(ctx);
-+	}
-+}
-+
-+#if defined(DUK_USE_DDDPRINT)
-+/* Debug print which visualizes the qsort partitioning process. */
-+DUK_LOCAL void duk__debuglog_qsort_state(duk_context *ctx, duk_int_t lo, duk_int_t hi, duk_int_t pivot) {
-+	char buf[4096];
-+	char *ptr = buf;
-+	duk_int_t i, n;
-+	n = (duk_int_t) duk_get_length(ctx, 1);
-+	if (n > 4000) {
-+		n = 4000;
-+	}
-+	*ptr++ = '[';
-+	for (i = 0; i < n; i++) {
-+		if (i == pivot) {
-+			*ptr++ = '|';
-+		} else if (i == lo) {
-+			*ptr++ = '<';
-+		} else if (i == hi) {
-+			*ptr++ = '>';
-+		} else if (i >= lo && i <= hi) {
-+			*ptr++ = '-';
-+		} else {
-+			*ptr++ = ' ';
-+		}
-+	}
-+	*ptr++ = ']';
-+	*ptr++ = '\0';
-+
-+	DUK_DDD(DUK_DDDPRINT("%s   (lo=%ld, hi=%ld, pivot=%ld)",
-+	                     (const char *) buf, (long) lo, (long) hi, (long) pivot));
-+}
-+#endif
-+
-+DUK_LOCAL void duk__array_qsort(duk_context *ctx, duk_int_t lo, duk_int_t hi) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_int_t p, l, r;
-+
-+	/* The lo/hi indices may be crossed and hi < 0 is possible at entry. */
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__array_qsort: lo=%ld, hi=%ld, obj=%!T",
-+	                     (long) lo, (long) hi, (duk_tval *) duk_get_tval(ctx, 1)));
-+
-+	DUK_ASSERT_TOP(ctx, 3);
-+
-+	/* In some cases it may be that lo > hi, or hi < 0; these
-+	 * degenerate cases happen e.g. for empty arrays, and in
-+	 * recursion leaves.
-+	 */
-+
-+	/* trivial cases */
-+	if (hi - lo < 1) {
-+		DUK_DDD(DUK_DDDPRINT("degenerate case, return immediately"));
-+		return;
-+	}
-+	DUK_ASSERT(hi > lo);
-+	DUK_ASSERT(hi - lo + 1 >= 2);
-+
-+	/* randomized pivot selection */
-+	p = lo + (duk_util_tinyrandom_get_bits(thr, 30) % (hi - lo + 1));  /* rnd in [lo,hi] */
-+	DUK_ASSERT(p >= lo && p <= hi);
-+	DUK_DDD(DUK_DDDPRINT("lo=%ld, hi=%ld, chose pivot p=%ld",
-+	                     (long) lo, (long) hi, (long) p));
-+
-+	/* move pivot out of the way */
-+	duk__array_sort_swap(ctx, p, lo);
-+	p = lo;
-+	DUK_DDD(DUK_DDDPRINT("pivot moved out of the way: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
-+
-+	l = lo + 1;
-+	r = hi;
-+	for (;;) {
-+		/* find elements to swap */
-+		for (;;) {
-+			DUK_DDD(DUK_DDDPRINT("left scan: l=%ld, r=%ld, p=%ld",
-+			                     (long) l, (long) r, (long) p));
-+			if (l >= hi) {
-+				break;
-+			}
-+			if (duk__array_sort_compare(ctx, l, p) >= 0) {  /* !(l < p) */
-+				break;
-+			}
-+			l++;
-+		}
-+		for (;;) {
-+			DUK_DDD(DUK_DDDPRINT("right scan: l=%ld, r=%ld, p=%ld",
-+			                     (long) l, (long) r, (long) p));
-+			if (r <= lo) {
-+				break;
-+			}
-+			if (duk__array_sort_compare(ctx, p, r) >= 0) {  /* !(p < r) */
-+				break;
-+			}
-+			r--;
-+		}
-+		if (l >= r) {
-+			goto done;
-+		}
-+		DUK_ASSERT(l < r);
-+
-+		DUK_DDD(DUK_DDDPRINT("swap %ld and %ld", (long) l, (long) r));
-+
-+		duk__array_sort_swap(ctx, l, r);
-+
-+		DUK_DDD(DUK_DDDPRINT("after swap: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
-+		l++;
-+		r--;
-+	}
-+ done:
-+	/* Note that 'l' and 'r' may cross, i.e. r < l */
-+	DUK_ASSERT(l >= lo && l <= hi);
-+	DUK_ASSERT(r >= lo && r <= hi);
-+
-+	/* XXX: there's no explicit recursion bound here now.  For the average
-+	 * qsort recursion depth O(log n) that's not really necessary: e.g. for
-+	 * 2**32 recursion depth would be about 32 which is OK.  However, qsort
-+	 * worst case recursion depth is O(n) which may be a problem.
-+	 */
-+
-+	/* move pivot to its final place */
-+	DUK_DDD(DUK_DDDPRINT("before final pivot swap: %!T", (duk_tval *) duk_get_tval(ctx, 1)));
-+	duk__array_sort_swap(ctx, lo, r);
-+
-+#if defined(DUK_USE_DDDPRINT)
-+	duk__debuglog_qsort_state(ctx, lo, hi, r);
-+#endif
-+
-+	DUK_DDD(DUK_DDDPRINT("recurse: pivot=%ld, obj=%!T", (long) r, (duk_tval *) duk_get_tval(ctx, 1)));
-+	duk__array_qsort(ctx, lo, r - 1);
-+	duk__array_qsort(ctx, r + 1, hi);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_sort(duk_context *ctx) {
-+	duk_uint32_t len;
-+
-+	/* XXX: len >= 0x80000000 won't work below because a signed type
-+	 * is needed by qsort.
-+	 */
-+	len = duk__push_this_obj_len_u32_limited(ctx);
-+
-+	/* stack[0] = compareFn
-+	 * stack[1] = ToObject(this)
-+	 * stack[2] = ToUint32(length)
-+	 */
-+
-+	if (len > 0) {
-+		/* avoid degenerate cases, so that (len - 1) won't underflow */
-+		duk__array_qsort(ctx, (duk_int_t) 0, (duk_int_t) (len - 1));
-+	}
-+
-+	DUK_ASSERT_TOP(ctx, 3);
-+	duk_pop(ctx);
-+	return 1;  /* return ToObject(this) */
-+}
-+
-+/*
-+ *  splice()
-+ */
-+
-+/* XXX: this compiles to over 500 bytes now, even without special handling
-+ * for an array part.  Uses signed ints so does not handle full array range correctly.
-+ */
-+
-+/* XXX: can shift() / unshift() use the same helper?
-+ *   shift() is (close to?) <--> splice(0, 1)
-+ *   unshift is (close to?) <--> splice(0, 0, [items])?
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_splice(duk_context *ctx) {
-+	duk_idx_t nargs;
-+	duk_uint32_t len;
-+	duk_bool_t have_delcount;
-+	duk_int_t item_count;
-+	duk_int_t act_start;
-+	duk_int_t del_count;
-+	duk_int_t i, n;
-+
-+	DUK_UNREF(have_delcount);
-+
-+	nargs = duk_get_top(ctx);
-+	if (nargs < 2) {
-+		duk_set_top(ctx, 2);
-+		nargs = 2;
-+		have_delcount = 0;
-+	} else {
-+		have_delcount = 1;
-+	}
-+
-+	/* XXX: len >= 0x80000000 won't work below because we need to be
-+	 * able to represent -len.
-+	 */
-+	len = duk__push_this_obj_len_u32_limited(ctx);
-+
-+	act_start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
-+	if (act_start < 0) {
-+		act_start = len + act_start;
-+	}
-+	DUK_ASSERT(act_start >= 0 && act_start <= (duk_int_t) len);
-+
-+#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
-+	if (have_delcount) {
-+#endif
-+		del_count = duk_to_int_clamped(ctx, 1, 0, len - act_start);
-+#ifdef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
-+	} else {
-+		/* E5.1 standard behavior when deleteCount is not given would be
-+		 * to treat it just like if 'undefined' was given, which coerces
-+		 * ultimately to 0.  Real world behavior is to splice to the end
-+		 * of array, see test-bi-array-proto-splice-no-delcount.js.
-+		 */
-+		del_count = len - act_start;
-+	}
-+#endif
-+
-+	DUK_ASSERT(nargs >= 2);
-+	item_count = (duk_int_t) (nargs - 2);
-+
-+	DUK_ASSERT(del_count >= 0 && del_count <= (duk_int_t) len - act_start);
-+	DUK_ASSERT(del_count + act_start <= (duk_int_t) len);
-+
-+	/* For now, restrict result array into 32-bit length range. */
-+	if (((duk_double_t) len) - ((duk_double_t) del_count) + ((duk_double_t) item_count) > (duk_double_t) DUK_UINT32_MAX) {
-+		DUK_D(DUK_DPRINT("Array.prototype.splice() would go beyond 32-bit length, throw"));
-+		return DUK_RET_RANGE_ERROR;
-+	}
-+
-+	duk_push_array(ctx);
-+
-+	/* stack[0] = start
-+	 * stack[1] = deleteCount
-+	 * stack[2...nargs-1] = items
-+	 * stack[nargs] = ToObject(this)               -3
-+	 * stack[nargs+1] = ToUint32(length)           -2
-+	 * stack[nargs+2] = result array               -1
-+	 */
-+
-+	DUK_ASSERT_TOP(ctx, nargs + 3);
-+
-+	/* Step 9: copy elements-to-be-deleted into the result array */
-+
-+	for (i = 0; i < del_count; i++) {
-+		if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (act_start + i))) {
-+			duk_xdef_prop_index_wec(ctx, -2, i);  /* throw flag irrelevant (false in std alg) */
-+		} else {
-+			duk_pop(ctx);
-+		}
-+	}
-+	duk_push_u32(ctx, (duk_uint32_t) del_count);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
-+
-+	/* Steps 12 and 13: reorganize elements to make room for itemCount elements */
-+
-+	if (item_count < del_count) {
-+		/*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 1
-+		 * -> [ A B F G H ]          (conceptual intermediate step)
-+		 * -> [ A B . F G H ]        (placeholder marked)
-+		 *    [ A B C F G H ]        (actual result at this point, C will be replaced)
-+		 */
-+
-+		DUK_ASSERT_TOP(ctx, nargs + 3);
-+
-+		n = len - del_count;
-+		for (i = act_start; i < n; i++) {
-+			if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) {
-+				duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count));
-+			} else {
-+				duk_pop(ctx);
-+				duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count));
-+			}
-+		}
-+
-+		DUK_ASSERT_TOP(ctx, nargs + 3);
-+
-+		/* loop iterator init and limit changed from standard algorithm */
-+		n = len - del_count + item_count;
-+		for (i = len - 1; i >= n; i--) {
-+			duk_del_prop_index(ctx, -3, (duk_uarridx_t) i);
-+		}
-+
-+		DUK_ASSERT_TOP(ctx, nargs + 3);
-+	} else if (item_count > del_count) {
-+		/*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 4
-+		 * -> [ A B F G H ]          (conceptual intermediate step)
-+		 * -> [ A B . . . . F G H ]  (placeholder marked)
-+		 *    [ A B C D E F F G H ]  (actual result at this point)
-+		 */
-+
-+		DUK_ASSERT_TOP(ctx, nargs + 3);
-+
-+		/* loop iterator init and limit changed from standard algorithm */
-+		for (i = len - del_count - 1; i >= act_start; i--) {
-+			if (duk_get_prop_index(ctx, -3, (duk_uarridx_t) (i + del_count))) {
-+				duk_put_prop_index(ctx, -4, (duk_uarridx_t) (i + item_count));
-+			} else {
-+				duk_pop(ctx);
-+				duk_del_prop_index(ctx, -3, (duk_uarridx_t) (i + item_count));
-+			}
-+		}
-+
-+		DUK_ASSERT_TOP(ctx, nargs + 3);
-+	} else {
-+		/*    [ A B C D E F G H ]    rel_index = 2, del_count 3, item count 3
-+		 * -> [ A B F G H ]          (conceptual intermediate step)
-+		 * -> [ A B . . . F G H ]    (placeholder marked)
-+		 *    [ A B C D E F G H ]    (actual result at this point)
-+		 */
-+	}
-+	DUK_ASSERT_TOP(ctx, nargs + 3);
-+
-+	/* Step 15: insert itemCount elements into the hole made above */
-+
-+	for (i = 0; i < item_count; i++) {
-+		duk_dup(ctx, i + 2);  /* args start at index 2 */
-+		duk_put_prop_index(ctx, -4, (duk_uarridx_t) (act_start + i));
-+	}
-+
-+	/* Step 16: update length; note that the final length may be above 32 bit range
-+	 * (but we checked above that this isn't the case here)
-+	 */
-+
-+	duk_push_u32(ctx, len - del_count + item_count);
-+	duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH);
-+
-+	/* result array is already at the top of stack */
-+	DUK_ASSERT_TOP(ctx, nargs + 3);
-+	return 1;
-+}
-+
-+/*
-+ *  reverse()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reverse(duk_context *ctx) {
-+	duk_uint32_t len;
-+	duk_uint32_t middle;
-+	duk_uint32_t lower, upper;
-+	duk_bool_t have_lower, have_upper;
-+
-+	len = duk__push_this_obj_len_u32(ctx);
-+	middle = len / 2;
-+
-+	/* If len <= 1, middle will be 0 and for-loop bails out
-+	 * immediately (0 < 0 -> false).
-+	 */
-+
-+	for (lower = 0; lower < middle; lower++) {
-+		DUK_ASSERT(len >= 2);
-+		DUK_ASSERT_TOP(ctx, 2);
-+
-+		DUK_ASSERT(len >= lower + 1);
-+		upper = len - lower - 1;
-+
-+		have_lower = duk_get_prop_index(ctx, -2, (duk_uarridx_t) lower);
-+		have_upper = duk_get_prop_index(ctx, -3, (duk_uarridx_t) upper);
-+
-+		/* [ ToObject(this) ToUint32(length) lowerValue upperValue ] */
-+
-+		if (have_upper) {
-+			duk_put_prop_index(ctx, -4, (duk_uarridx_t) lower);
-+		} else {
-+			duk_del_prop_index(ctx, -4, (duk_uarridx_t) lower);
-+			duk_pop(ctx);
-+		}
-+
-+		if (have_lower) {
-+			duk_put_prop_index(ctx, -3, (duk_uarridx_t) upper);
-+		} else {
-+			duk_del_prop_index(ctx, -3, (duk_uarridx_t) upper);
-+			duk_pop(ctx);
-+		}
-+
-+		DUK_ASSERT_TOP(ctx, 2);
-+	}
-+
-+	DUK_ASSERT_TOP(ctx, 2);
-+	duk_pop(ctx);  /* -> [ ToObject(this) ] */
-+	return 1;
-+}
-+
-+/*
-+ *  slice()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_slice(duk_context *ctx) {
-+	duk_uint32_t len;
-+	duk_int_t start, end;
-+	duk_int_t i;
-+	duk_uarridx_t idx;
-+	duk_uint32_t res_length = 0;
-+
-+	/* XXX: len >= 0x80000000 won't work below because we need to be
-+	 * able to represent -len.
-+	 */
-+	len = duk__push_this_obj_len_u32_limited(ctx);
-+	duk_push_array(ctx);
-+
-+	/* stack[0] = start
-+	 * stack[1] = end
-+	 * stack[2] = ToObject(this)
-+	 * stack[3] = ToUint32(length)
-+	 * stack[4] = result array
-+	 */
-+
-+	start = duk_to_int_clamped(ctx, 0, -((duk_int_t) len), (duk_int_t) len);
-+	if (start < 0) {
-+		start = len + start;
-+	}
-+	/* XXX: could duk_is_undefined() provide defaulting undefined to 'len'
-+	 * (the upper limit)?
-+	 */
-+	if (duk_is_undefined(ctx, 1)) {
-+		end = len;
-+	} else {
-+		end = duk_to_int_clamped(ctx, 1, -((duk_int_t) len), (duk_int_t) len);
-+		if (end < 0) {
-+			end = len + end;
-+		}
-+	}
-+	DUK_ASSERT(start >= 0 && (duk_uint32_t) start <= len);
-+	DUK_ASSERT(end >= 0 && (duk_uint32_t) end <= len);
-+
-+	idx = 0;
-+	for (i = start; i < end; i++) {
-+		DUK_ASSERT_TOP(ctx, 5);
-+		if (duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
-+			duk_xdef_prop_index_wec(ctx, 4, idx);
-+			res_length = idx + 1;
-+		} else {
-+			duk_pop(ctx);
-+		}
-+		idx++;
-+		DUK_ASSERT_TOP(ctx, 5);
-+	}
-+
-+	duk_push_u32(ctx, res_length);
-+	duk_xdef_prop_stridx(ctx, 4, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
-+
-+	DUK_ASSERT_TOP(ctx, 5);
-+	return 1;
-+}
-+
-+/*
-+ *  shift()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_shift(duk_context *ctx) {
-+	duk_uint32_t len;
-+	duk_uint32_t i;
-+
-+	len = duk__push_this_obj_len_u32(ctx);
-+	if (len == 0) {
-+		duk_push_int(ctx, 0);
-+		duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
-+		return 0;
-+	}
-+
-+	duk_get_prop_index(ctx, 0, 0);
-+
-+	/* stack[0] = object (this)
-+	 * stack[1] = ToUint32(length)
-+	 * stack[2] = elem at index 0 (retval)
-+	 */
-+
-+	for (i = 1; i < len; i++) {
-+		DUK_ASSERT_TOP(ctx, 3);
-+		if (duk_get_prop_index(ctx, 0, (duk_uarridx_t) i)) {
-+			/* fromPresent = true */
-+			duk_put_prop_index(ctx, 0, (duk_uarridx_t) (i - 1));
-+		} else {
-+			/* fromPresent = false */
-+			duk_del_prop_index(ctx, 0, (duk_uarridx_t) (i - 1));
-+			duk_pop(ctx);
-+		}
-+	}
-+	duk_del_prop_index(ctx, 0, (duk_uarridx_t) (len - 1));
-+
-+	duk_push_u32(ctx, (duk_uint32_t) (len - 1));
-+	duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LENGTH);
-+
-+	DUK_ASSERT_TOP(ctx, 3);
-+	return 1;
-+}
-+
-+/*
-+ *  unshift()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_unshift(duk_context *ctx) {
-+	duk_idx_t nargs;
-+	duk_uint32_t len;
-+	duk_uint32_t i;
-+
-+	nargs = duk_get_top(ctx);
-+	len = duk__push_this_obj_len_u32(ctx);
-+
-+	/* stack[0...nargs-1] = unshift args (vararg)
-+	 * stack[nargs] = ToObject(this)
-+	 * stack[nargs+1] = ToUint32(length)
-+	 */
-+
-+	DUK_ASSERT_TOP(ctx, nargs + 2);
-+
-+	/* Note: unshift() may operate on indices above unsigned 32-bit range
-+	 * and the final length may be >= 2**32.  However, we restrict the
-+	 * final result to 32-bit range for practicality.
-+	 */
-+
-+	if (len + (duk_uint32_t) nargs < len) {
-+		DUK_D(DUK_DPRINT("Array.prototype.unshift() would go beyond 32-bit length, throw"));
-+		return DUK_RET_RANGE_ERROR;
-+	}
-+
-+	i = len;
-+	while (i > 0) {
-+		DUK_ASSERT_TOP(ctx, nargs + 2);
-+		i--;
-+		/* k+argCount-1; note that may be above 32-bit range */
-+
-+		if (duk_get_prop_index(ctx, -2, (duk_uarridx_t) i)) {
-+			/* fromPresent = true */
-+			/* [ ... ToObject(this) ToUint32(length) val ] */
-+			duk_put_prop_index(ctx, -3, (duk_uarridx_t) (i + nargs));  /* -> [ ... ToObject(this) ToUint32(length) ] */
-+		} else {
-+			/* fromPresent = false */
-+			/* [ ... ToObject(this) ToUint32(length) val ] */
-+			duk_pop(ctx);
-+			duk_del_prop_index(ctx, -2, (duk_uarridx_t) (i + nargs));  /* -> [ ... ToObject(this) ToUint32(length) ] */
-+		}
-+		DUK_ASSERT_TOP(ctx, nargs + 2);
-+	}
-+
-+	for (i = 0; i < (duk_uint32_t) nargs; i++) {
-+		DUK_ASSERT_TOP(ctx, nargs + 2);
-+		duk_dup(ctx, i);  /* -> [ ... ToObject(this) ToUint32(length) arg[i] ] */
-+		duk_put_prop_index(ctx, -3, (duk_uarridx_t) i);
-+		DUK_ASSERT_TOP(ctx, nargs + 2);
-+	}
-+
-+	DUK_ASSERT_TOP(ctx, nargs + 2);
-+	duk_push_u32(ctx, len + nargs);
-+	duk_dup_top(ctx);  /* -> [ ... ToObject(this) ToUint32(length) final_len final_len ] */
-+	duk_put_prop_stridx(ctx, -4, DUK_STRIDX_LENGTH);
-+	return 1;
-+}
-+
-+/*
-+ *  indexOf(), lastIndexOf()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_indexof_shared(duk_context *ctx) {
-+	duk_idx_t nargs;
-+	duk_int_t i, len;
-+	duk_int_t from_index;
-+	duk_small_int_t idx_step = duk_get_current_magic(ctx);  /* idx_step is +1 for indexOf, -1 for lastIndexOf */
-+
-+	/* lastIndexOf() needs to be a vararg function because we must distinguish
-+	 * between an undefined fromIndex and a "not given" fromIndex; indexOf() is
-+	 * made vararg for symmetry although it doesn't strictly need to be.
-+	 */
-+
-+	nargs = duk_get_top(ctx);
-+	duk_set_top(ctx, 2);
-+
-+	/* XXX: must be able to represent -len */
-+	len = (duk_int_t) duk__push_this_obj_len_u32_limited(ctx);
-+	if (len == 0) {
-+		goto not_found;
-+	}
-+
-+	/* Index clamping is a bit tricky, we must ensure that we'll only iterate
-+	 * through elements that exist and that the specific requirements from E5.1
-+	 * Sections 15.4.4.14 and 15.4.4.15 are fulfilled; especially:
-+	 *
-+	 *   - indexOf: clamp to [-len,len], negative handling -> [0,len],
-+	 *     if clamped result is len, for-loop bails out immediately
-+	 *
-+	 *   - lastIndexOf: clamp to [-len-1, len-1], negative handling -> [-1, len-1],
-+	 *     if clamped result is -1, for-loop bails out immediately
-+	 *
-+	 * If fromIndex is not given, ToInteger(undefined) = 0, which is correct
-+	 * for indexOf() but incorrect for lastIndexOf().  Hence special handling,
-+	 * and why lastIndexOf() needs to be a vararg function.
-+	 */
-+
-+	if (nargs >= 2) {
-+		/* indexOf: clamp fromIndex to [-len, len]
-+		 * (if fromIndex == len, for-loop terminates directly)
-+		 *
-+		 * lastIndexOf: clamp fromIndex to [-len - 1, len - 1]
-+		 * (if clamped to -len-1 -> fromIndex becomes -1, terminates for-loop directly)
-+		 */
-+		from_index = duk_to_int_clamped(ctx,
-+		                                1,
-+		                                (idx_step > 0 ? -len : -len - 1),
-+		                                (idx_step > 0 ? len : len - 1));
-+		if (from_index < 0) {
-+			/* for lastIndexOf, result may be -1 (mark immediate termination) */
-+			from_index = len + from_index;
-+		}
-+	} else {
-+		/* for indexOf, ToInteger(undefined) would be 0, i.e. correct, but
-+		 * handle both indexOf and lastIndexOf specially here.
-+		 */
-+		if (idx_step > 0) {
-+			from_index = 0;
-+		} else {
-+			from_index = len - 1;
-+		}
-+	}
-+
-+	/* stack[0] = searchElement
-+	 * stack[1] = fromIndex
-+	 * stack[2] = object
-+	 * stack[3] = length (not needed, but not popped above)
-+	 */
-+
-+	for (i = from_index; i >= 0 && i < len; i += idx_step) {
-+		DUK_ASSERT_TOP(ctx, 4);
-+
-+		if (duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
-+			DUK_ASSERT_TOP(ctx, 5);
-+			if (duk_strict_equals(ctx, 0, 4)) {
-+				duk_push_int(ctx, i);
-+				return 1;
-+			}
-+		}
-+
-+		duk_pop(ctx);
-+	}
-+
-+ not_found:
-+	duk_push_int(ctx, -1);
-+	return 1;
-+}
-+
-+/*
-+ *  every(), some(), forEach(), map(), filter()
-+ */
-+
-+#define DUK__ITER_EVERY    0
-+#define DUK__ITER_SOME     1
-+#define DUK__ITER_FOREACH  2
-+#define DUK__ITER_MAP      3
-+#define DUK__ITER_FILTER   4
-+
-+/* XXX: This helper is a bit awkward because the handling for the different iteration
-+ * callers is quite different.  This now compiles to a bit less than 500 bytes, so with
-+ * 5 callers the net result is about 100 bytes / caller.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_iter_shared(duk_context *ctx) {
-+	duk_uint32_t len;
-+	duk_uint32_t i;
-+	duk_uarridx_t k;
-+	duk_bool_t bval;
-+	duk_small_int_t iter_type = duk_get_current_magic(ctx);
-+	duk_uint32_t res_length = 0;
-+
-+	/* each call this helper serves has nargs==2 */
-+	DUK_ASSERT_TOP(ctx, 2);
-+
-+	len = duk__push_this_obj_len_u32(ctx);
-+	if (!duk_is_callable(ctx, 0)) {
-+		goto type_error;
-+	}
-+	/* if thisArg not supplied, behave as if undefined was supplied */
-+
-+	if (iter_type == DUK__ITER_MAP || iter_type == DUK__ITER_FILTER) {
-+		duk_push_array(ctx);
-+	} else {
-+		duk_push_undefined(ctx);
-+	}
-+
-+	/* stack[0] = callback
-+	 * stack[1] = thisArg
-+	 * stack[2] = object
-+	 * stack[3] = ToUint32(length)  (unused, but avoid unnecessary pop)
-+	 * stack[4] = result array (or undefined)
-+	 */
-+
-+	k = 0;  /* result index for filter() */
-+	for (i = 0; i < len; i++) {
-+		DUK_ASSERT_TOP(ctx, 5);
-+
-+		if (!duk_get_prop_index(ctx, 2, (duk_uarridx_t) i)) {
-+#if defined(DUK_USE_NONSTD_ARRAY_MAP_TRAILER)
-+			/* Real world behavior for map(): trailing non-existent
-+			 * elements don't invoke the user callback, but are still
-+			 * counted towards result 'length'.
-+			 */
-+			if (iter_type == DUK__ITER_MAP) {
-+				res_length = i + 1;
-+			}
-+#else
-+			/* Standard behavior for map(): trailing non-existent
-+			 * elements don't invoke the user callback and are not
-+			 * counted towards result 'length'.
-+			 */
-+#endif
-+			duk_pop(ctx);
-+			continue;
-+		}
-+
-+		/* The original value needs to be preserved for filter(), hence
-+		 * this funny order.  We can't re-get the value because of side
-+		 * effects.
-+		 */
-+
-+		duk_dup(ctx, 0);
-+		duk_dup(ctx, 1);
-+		duk_dup(ctx, -3);
-+		duk_push_u32(ctx, i);
-+		duk_dup(ctx, 2);  /* [ ... val callback thisArg val i obj ] */
-+		duk_call_method(ctx, 3); /* -> [ ... val retval ] */
-+
-+		switch (iter_type) {
-+		case DUK__ITER_EVERY:
-+			bval = duk_to_boolean(ctx, -1);
-+			if (!bval) {
-+				/* stack top contains 'false' */
-+				return 1;
-+			}
-+			break;
-+		case DUK__ITER_SOME:
-+			bval = duk_to_boolean(ctx, -1);
-+			if (bval) {
-+				/* stack top contains 'true' */
-+				return 1;
-+			}
-+			break;
-+		case DUK__ITER_FOREACH:
-+			/* nop */
-+			break;
-+		case DUK__ITER_MAP:
-+			duk_dup(ctx, -1);
-+			duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) i);  /* retval to result[i] */
-+			res_length = i + 1;
-+			break;
-+		case DUK__ITER_FILTER:
-+			bval = duk_to_boolean(ctx, -1);
-+			if (bval) {
-+				duk_dup(ctx, -2);  /* orig value */
-+				duk_xdef_prop_index_wec(ctx, 4, (duk_uarridx_t) k);
-+				k++;
-+				res_length = k;
-+			}
-+			break;
-+		default:
-+			DUK_UNREACHABLE();
-+			break;
-+		}
-+		duk_pop_2(ctx);
-+
-+		DUK_ASSERT_TOP(ctx, 5);
-+	}
-+
-+	switch (iter_type) {
-+	case DUK__ITER_EVERY:
-+		duk_push_true(ctx);
-+		break;
-+	case DUK__ITER_SOME:
-+		duk_push_false(ctx);
-+		break;
-+	case DUK__ITER_FOREACH:
-+		duk_push_undefined(ctx);
-+		break;
-+	case DUK__ITER_MAP:
-+	case DUK__ITER_FILTER:
-+		DUK_ASSERT_TOP(ctx, 5);
-+		DUK_ASSERT(duk_is_array(ctx, -1));  /* topmost element is the result array already */
-+		duk_push_u32(ctx, res_length);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_W);
-+		break;
-+	default:
-+		DUK_UNREACHABLE();
-+		break;
-+	}
-+
-+	return 1;
-+
-+ type_error:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+
-+/*
-+ *  reduce(), reduceRight()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_array_prototype_reduce_shared(duk_context *ctx) {
-+	duk_idx_t nargs;
-+	duk_bool_t have_acc;
-+	duk_uint32_t i, len;
-+	duk_small_int_t idx_step = duk_get_current_magic(ctx);  /* idx_step is +1 for reduce, -1 for reduceRight */
-+
-+	/* We're a varargs function because we need to detect whether
-+	 * initialValue was given or not.
-+	 */
-+	nargs = duk_get_top(ctx);
-+	DUK_DDD(DUK_DDDPRINT("nargs=%ld", (long) nargs));
-+
-+	duk_set_top(ctx, 2);
-+	len = duk__push_this_obj_len_u32(ctx);
-+	if (!duk_is_callable(ctx, 0)) {
-+		goto type_error;
-+	}
-+
-+	/* stack[0] = callback fn
-+	 * stack[1] = initialValue
-+	 * stack[2] = object (coerced this)
-+	 * stack[3] = length (not needed, but not popped above)
-+	 * stack[4] = accumulator
-+	 */
-+
-+	have_acc = 0;
-+	if (nargs >= 2) {
-+		duk_dup(ctx, 1);
-+		have_acc = 1;
-+	}
-+	DUK_DDD(DUK_DDDPRINT("have_acc=%ld, acc=%!T",
-+	                     (long) have_acc, (duk_tval *) duk_get_tval(ctx, 3)));
-+
-+	/* For len == 0, i is initialized to len - 1 which underflows.
-+	 * The condition (i < len) will then exit the for-loop on the
-+	 * first round which is correct.  Similarly, loop termination
-+	 * happens by i underflowing.
-+	 */
-+
-+	for (i = (idx_step >= 0 ? 0 : len - 1);
-+	     i < len;  /* i >= 0 would always be true */
-+	     i += idx_step) {
-+		DUK_DDD(DUK_DDDPRINT("i=%ld, len=%ld, have_acc=%ld, top=%ld, acc=%!T",
-+		                     (long) i, (long) len, (long) have_acc,
-+		                     (long) duk_get_top(ctx),
-+		                     (duk_tval *) duk_get_tval(ctx, 4)));
-+
-+		DUK_ASSERT((have_acc && duk_get_top(ctx) == 5) ||
-+		           (!have_acc && duk_get_top(ctx) == 4));
-+
-+		if (!duk_has_prop_index(ctx, 2, (duk_uarridx_t) i)) {
-+			continue;
-+		}
-+
-+		if (!have_acc) {
-+			DUK_ASSERT_TOP(ctx, 4);
-+			duk_get_prop_index(ctx, 2, (duk_uarridx_t) i);
-+			have_acc = 1;
-+			DUK_ASSERT_TOP(ctx, 5);
-+		} else {
-+			DUK_ASSERT_TOP(ctx, 5);
-+			duk_dup(ctx, 0);
-+			duk_dup(ctx, 4);
-+			duk_get_prop_index(ctx, 2, (duk_uarridx_t) i);
-+			duk_push_u32(ctx, i);
-+			duk_dup(ctx, 2);
-+			DUK_DDD(DUK_DDDPRINT("calling reduce function: func=%!T, prev=%!T, curr=%!T, idx=%!T, obj=%!T",
-+			                     (duk_tval *) duk_get_tval(ctx, -5), (duk_tval *) duk_get_tval(ctx, -4),
-+			                     (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2),
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			duk_call(ctx, 4);
-+			DUK_DDD(DUK_DDDPRINT("-> result: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+			duk_replace(ctx, 4);
-+			DUK_ASSERT_TOP(ctx, 5);
-+		}
-+	}
-+
-+	if (!have_acc) {
-+		goto type_error;
-+	}
-+
-+	DUK_ASSERT_TOP(ctx, 5);
-+	return 1;
-+
-+ type_error:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+#line 1 "duk_bi_boolean.c"
-+/*
-+ *  Boolean built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* Shared helper to provide toString() and valueOf().  Checks 'this', gets
-+ * the primitive value to stack top, and optionally coerces with ToString().
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_boolean_prototype_tostring_shared(duk_context *ctx) {
-+	duk_tval *tv;
-+	duk_hobject *h;
-+	duk_small_int_t coerce_tostring = duk_get_current_magic(ctx);
-+
-+	/* XXX: there is room to use a shared helper here, many built-ins
-+	 * check the 'this' type, and if it's an object, check its class,
-+	 * then get its internal value, etc.
-+	 */
-+
-+	duk_push_this(ctx);
-+	tv = duk_get_tval(ctx, -1);
-+	DUK_ASSERT(tv != NULL);
-+
-+	if (DUK_TVAL_IS_BOOLEAN(tv)) {
-+		goto type_ok;
-+	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-+		h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+
-+		if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_BOOLEAN) {
-+			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-+			DUK_ASSERT(duk_is_boolean(ctx, -1));
-+			goto type_ok;
-+		}
-+	}
-+
-+	return DUK_RET_TYPE_ERROR;
-+
-+ type_ok:
-+	if (coerce_tostring) {
-+		duk_to_string(ctx, -1);
-+	}
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_boolean_constructor(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h_this;
-+
-+	DUK_UNREF(thr);
-+
-+	duk_to_boolean(ctx, 0);
-+
-+	if (duk_is_constructor_call(ctx)) {
-+		/* XXX: helper; rely on Boolean.prototype as being non-writable, non-configurable */
-+		duk_push_this(ctx);
-+		h_this = duk_get_hobject(ctx, -1);
-+		DUK_ASSERT(h_this != NULL);
-+		DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_this) == thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE]);
-+
-+		DUK_HOBJECT_SET_CLASS_NUMBER(h_this, DUK_HOBJECT_CLASS_BOOLEAN);
-+
-+		duk_dup(ctx, 0);  /* -> [ val obj val ] */
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);  /* XXX: proper flags? */
-+	}  /* unbalanced stack */
-+
-+	return 1;
-+}
-+#line 1 "duk_bi_buffer.c"
-+/*
-+ *  Buffer built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Constructor
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_buffer_constructor(duk_context *ctx) {
-+	duk_size_t buf_size;
-+	duk_small_int_t buf_dynamic;
-+	duk_uint8_t *buf_data;
-+	const duk_uint8_t *src_data;
-+	duk_hobject *h_obj;
-+
-+	/*
-+	 *  Constructor arguments are currently somewhat compatible with
-+	 *  (keep it that way if possible):
-+	 *
-+	 *    http://nodejs.org/api/buffer.html
-+	 *
-+	 *  Note that the ToBuffer() coercion (duk_to_buffer()) does NOT match
-+	 *  the constructor behavior.
-+	 */
-+
-+	buf_dynamic = duk_get_boolean(ctx, 1);  /* default to false */
-+
-+	switch (duk_get_type(ctx, 0)) {
-+	case DUK_TYPE_NUMBER:
-+		/* new buffer of specified size */
-+		buf_size = (duk_size_t) duk_to_int(ctx, 0);
-+		(void) duk_push_buffer(ctx, buf_size, buf_dynamic);
-+		break;
-+	case DUK_TYPE_BUFFER:
-+		/* return input buffer, converted to a Buffer object if called as a
-+		 * constructor (no change if called as a function).
-+		 */
-+		duk_set_top(ctx, 1);
-+		break;
-+	case DUK_TYPE_STRING:
-+		/* new buffer with string contents */
-+		src_data = (const duk_uint8_t *) duk_get_lstring(ctx, 0, &buf_size);
-+		DUK_ASSERT(src_data != NULL);  /* even for zero-length string */
-+		buf_data = (duk_uint8_t *) duk_push_buffer(ctx, buf_size, buf_dynamic);
-+		DUK_MEMCPY((void *) buf_data, (const void *) src_data, (size_t) buf_size);
-+		break;
-+	case DUK_TYPE_OBJECT:
-+		/* Buffer object: get the plain buffer inside.  If called as as
-+		 * constructor, a new Buffer object pointing to the same plain
-+		 * buffer is created below.
-+		 */
-+		h_obj = duk_get_hobject(ctx, 0);
-+		DUK_ASSERT(h_obj != NULL);
-+		if (DUK_HOBJECT_GET_CLASS_NUMBER(h_obj) != DUK_HOBJECT_CLASS_BUFFER) {
-+			return DUK_RET_TYPE_ERROR;
-+		}
-+		duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_VALUE);
-+		DUK_ASSERT(duk_is_buffer(ctx, -1));
-+		break;
-+	case DUK_TYPE_NONE:
-+	default:
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+
-+	/* stack is unbalanced, but: [ <something> buf ] */
-+
-+	if (duk_is_constructor_call(ctx)) {
-+		duk_push_object_helper(ctx,
-+		                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		                       DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ |
-+		                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_BUFFER),
-+		                       DUK_BIDX_BUFFER_PROTOTYPE);
-+
-+		/* Buffer object internal value is immutable */
-+		duk_dup(ctx, -2);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
-+	}
-+	/* Note: unbalanced stack on purpose */
-+
-+	return 1;
-+}
-+
-+/*
-+ *  toString(), valueOf()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_buffer_prototype_tostring_shared(duk_context *ctx) {
-+	duk_tval *tv;
-+	duk_small_int_t to_string = duk_get_current_magic(ctx);
-+
-+	duk_push_this(ctx);
-+	tv = duk_require_tval(ctx, -1);
-+	DUK_ASSERT(tv != NULL);
-+
-+	if (DUK_TVAL_IS_BUFFER(tv)) {
-+		/* nop */
-+	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-+		duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+
-+		/* Must be a "buffer object", i.e. class "Buffer" */
-+		if (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_BUFFER) {
-+			goto type_error;
-+		}
-+
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-+	} else {
-+		goto type_error;
-+	}
-+
-+	if (to_string) {
-+		duk_to_string(ctx, -1);
-+	}
-+	return 1;
-+
-+ type_error:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+#line 1 "duk_bi_date.c"
-+/*
-+ *  Date built-ins
-+ *
-+ *  Unlike most built-ins, Date has a lot of platform dependencies for
-+ *  getting UTC time, converting between UTC and local time, and parsing
-+ *  and formatting time values.
-+ *
-+ *  See doc/datetime.txt.
-+ *
-+ *  Platform specific links:
-+ *
-+ *    - http://msdn.microsoft.com/en-us/library/windows/desktop/ms725473(v=vs.85).aspx
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Platform specific includes and defines
-+ *
-+ *  Note that necessary system headers (like <sys/time.h>) are included
-+ *  by duk_internal.h (or duk_features.h, which is included by duk_internal.h)
-+ *  because the header locations vary between systems and we don't want
-+ *  that clutter here.
-+ */
-+
-+#define DUK__GET_NOW_TIMEVAL      duk_bi_date_get_now
-+#define DUK__GET_LOCAL_TZOFFSET   duk__get_local_tzoffset
-+
-+/* Buffer sizes for some UNIX calls.  Larger than strictly necessary
-+ * to avoid Valgrind errors.
-+ */
-+#define DUK__STRPTIME_BUF_SIZE  64
-+#define DUK__STRFTIME_BUF_SIZE  64
-+
-+/*
-+ *  Other file level defines
-+ */
-+
-+/* Forward declarations. */
-+DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval_tzoffset(duk_context *ctx, duk_small_uint_t flags, duk_int_t *out_tzoffset);
-+DUK_LOCAL_DECL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_uint_t flags);
-+DUK_LOCAL_DECL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags);
-+DUK_LOCAL_DECL duk_double_t duk__get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags);
-+DUK_LOCAL_DECL void duk__twodigit_year_fixup(duk_context *ctx, duk_idx_t idx_val);
-+DUK_LOCAL_DECL duk_bool_t duk__is_leap_year(duk_int_t year);
-+DUK_LOCAL_DECL duk_bool_t duk__timeval_in_valid_range(duk_double_t x);
-+DUK_LOCAL_DECL duk_bool_t duk__timeval_in_leeway_range(duk_double_t x);
-+DUK_LOCAL_DECL duk_bool_t duk__year_in_valid_range(duk_double_t year);
-+
-+/* Millisecond count constants. */
-+#define DUK__MS_SECOND          1000L
-+#define DUK__MS_MINUTE          (60L * 1000L)
-+#define DUK__MS_HOUR            (60L * 60L * 1000L)
-+#define DUK__MS_DAY             (24L * 60L * 60L * 1000L)
-+
-+/* Ecmascript date range is 100 million days from Epoch:
-+ * > 100e6 * 24 * 60 * 60 * 1000  // 100M days in millisecs
-+ * 8640000000000000
-+ * (= 8.64e15)
-+ */
-+#define DUK__MS_100M_DAYS         (8.64e15)
-+#define DUK__MS_100M_DAYS_LEEWAY  (8.64e15 + 24 * 3600e3)
-+
-+/* Ecmascript year range:
-+ * > new Date(100e6 * 24 * 3600e3).toISOString()
-+ * '+275760-09-13T00:00:00.000Z'
-+ * > new Date(-100e6 * 24 * 3600e3).toISOString()
-+ * '-271821-04-20T00:00:00.000Z'
-+ */
-+#define  DUK__MIN_ECMA_YEAR     (-271821)
-+#define  DUK__MAX_ECMA_YEAR     275760
-+
-+/* Part indices for internal breakdowns.  Part order from DUK__IDX_YEAR to
-+ * DUK__IDX_MILLISECOND matches argument ordering of Ecmascript API calls
-+ * (like Date constructor call).  A few functions in this file depend
-+ * on the specific ordering, so change with care.  16 bits are not enough
-+ * for all parts (year, specifically).
-+ *
-+ * (Must be in-sync with genbuiltins.py.)
-+ */
-+#define DUK__IDX_YEAR           0  /* year */
-+#define DUK__IDX_MONTH          1  /* month: 0 to 11 */
-+#define DUK__IDX_DAY            2  /* day within month: 0 to 30 */
-+#define DUK__IDX_HOUR           3
-+#define DUK__IDX_MINUTE         4
-+#define DUK__IDX_SECOND         5
-+#define DUK__IDX_MILLISECOND    6
-+#define DUK__IDX_WEEKDAY        7  /* weekday: 0 to 6, 0=sunday, 1=monday, etc */
-+#define DUK__NUM_PARTS          8
-+
-+/* Internal API call flags, used for various functions in this file.
-+ * Certain flags are used by only certain functions, but since the flags
-+ * don't overlap, a single flags value can be passed around to multiple
-+ * functions.
-+ *
-+ * The unused top bits of the flags field are also used to pass values
-+ * to helpers (duk__get_part_helper() and duk__set_part_helper()).
-+ *
-+ * (Must be in-sync with genbuiltins.py.)
-+ */
-+#define DUK__FLAG_NAN_TO_ZERO          (1 << 0)  /* timeval breakdown: internal time value NaN -> zero */
-+#define DUK__FLAG_NAN_TO_RANGE_ERROR   (1 << 1)  /* timeval breakdown: internal time value NaN -> RangeError (toISOString) */
-+#define DUK__FLAG_ONEBASED             (1 << 2)  /* timeval breakdown: convert month and day-of-month parts to one-based (default is zero-based) */
-+#define DUK__FLAG_EQUIVYEAR            (1 << 3)  /* timeval breakdown: replace year with equivalent year in the [1971,2037] range for DST calculations */
-+#define DUK__FLAG_LOCALTIME            (1 << 4)  /* convert time value to local time */
-+#define DUK__FLAG_SUB1900              (1 << 5)  /* getter: subtract 1900 from year when getting year part */
-+#define DUK__FLAG_TOSTRING_DATE        (1 << 6)  /* include date part in string conversion result */
-+#define DUK__FLAG_TOSTRING_TIME        (1 << 7)  /* include time part in string conversion result */
-+#define DUK__FLAG_TOSTRING_LOCALE      (1 << 8)  /* use locale specific formatting if available */
-+#define DUK__FLAG_TIMESETTER           (1 << 9)  /* setter: call is a time setter (affects hour, min, sec, ms); otherwise date setter (affects year, month, day-in-month) */
-+#define DUK__FLAG_YEAR_FIXUP           (1 << 10) /* setter: perform 2-digit year fixup (00...99 -> 1900...1999) */
-+#define DUK__FLAG_SEP_T                (1 << 11) /* string conversion: use 'T' instead of ' ' as a separator */
-+#define DUK__FLAG_VALUE_SHIFT          12        /* additional values begin at bit 12 */
-+
-+/* Debug macro to print all parts and dparts (used manually because of debug level). */
-+#define  DUK__DPRINT_PARTS_AND_DPARTS(parts,dparts)  do { \
-+		DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld, dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \
-+		                 (long) (parts)[0], (long) (parts)[1], \
-+		                 (long) (parts)[2], (long) (parts)[3], \
-+		                 (long) (parts)[4], (long) (parts)[5], \
-+		                 (long) (parts)[6], (long) (parts)[7], \
-+		                 (double) (dparts)[0], (double) (dparts)[1], \
-+		                 (double) (dparts)[2], (double) (dparts)[3], \
-+		                 (double) (dparts)[4], (double) (dparts)[5], \
-+		                 (double) (dparts)[6], (double) (dparts)[7])); \
-+	} while (0)
-+#define  DUK__DPRINT_PARTS(parts)  do { \
-+		DUK_D(DUK_DPRINT("parts: %ld %ld %ld %ld %ld %ld %ld %ld", \
-+		                 (long) (parts)[0], (long) (parts)[1], \
-+		                 (long) (parts)[2], (long) (parts)[3], \
-+		                 (long) (parts)[4], (long) (parts)[5], \
-+		                 (long) (parts)[6], (long) (parts)[7])); \
-+	} while (0)
-+#define  DUK__DPRINT_DPARTS(dparts)  do { \
-+		DUK_D(DUK_DPRINT("dparts: %lf %lf %lf %lf %lf %lf %lf %lf", \
-+		                 (double) (dparts)[0], (double) (dparts)[1], \
-+		                 (double) (dparts)[2], (double) (dparts)[3], \
-+		                 (double) (dparts)[4], (double) (dparts)[5], \
-+		                 (double) (dparts)[6], (double) (dparts)[7])); \
-+	} while (0)
-+
-+/* Equivalent year for DST calculations outside [1970,2038[ range, see
-+ * E5 Section 15.9.1.8.  Equivalent year has the same leap-year-ness and
-+ * starts with the same weekday on Jan 1.
-+ * https://bugzilla.mozilla.org/show_bug.cgi?id=351066
-+ */
-+#define DUK__YEAR(x) ((duk_uint8_t) ((x) - 1970))
-+DUK_LOCAL duk_uint8_t duk__date_equivyear[14] = {
-+#if 1
-+	/* This is based on V8 EquivalentYear() algorithm (see src/genequivyear.py):
-+	 * http://code.google.com/p/v8/source/browse/trunk/src/date.h#146
-+	 */
-+
-+	/* non-leap year: sunday, monday, ... */
-+	DUK__YEAR(2023), DUK__YEAR(2035), DUK__YEAR(2019), DUK__YEAR(2031),
-+	DUK__YEAR(2015), DUK__YEAR(2027), DUK__YEAR(2011),
-+
-+	/* leap year: sunday, monday, ... */
-+	DUK__YEAR(2012), DUK__YEAR(2024), DUK__YEAR(2008), DUK__YEAR(2020),
-+	DUK__YEAR(2032), DUK__YEAR(2016), DUK__YEAR(2028)
-+#endif
-+
-+#if 0
-+	/* This is based on Rhino EquivalentYear() algorithm:
-+	 * https://github.com/mozilla/rhino/blob/f99cc11d616f0cdda2c42bde72b3484df6182947/src/org/mozilla/javascript/NativeDate.java
-+	 */
-+
-+	/* non-leap year: sunday, monday, ... */
-+	DUK__YEAR(1978), DUK__YEAR(1973), DUK__YEAR(1985), DUK__YEAR(1986),
-+	DUK__YEAR(1981), DUK__YEAR(1971), DUK__YEAR(1977),
-+
-+	/* leap year: sunday, monday, ... */
-+	DUK__YEAR(1984), DUK__YEAR(1996), DUK__YEAR(1980), DUK__YEAR(1992),
-+	DUK__YEAR(1976), DUK__YEAR(1988), DUK__YEAR(1972)
-+#endif
-+};
-+#undef DUK__YEAR
-+
-+/*
-+ *  Platform specific helpers
-+ */
-+
-+#ifdef DUK_USE_DATE_NOW_GETTIMEOFDAY
-+/* Get current Ecmascript time (= UNIX/Posix time, but in milliseconds). */
-+DUK_INTERNAL duk_double_t duk_bi_date_get_now(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	struct timeval tv;
-+	duk_double_t d;
-+
-+	if (gettimeofday(&tv, NULL) != 0) {
-+		DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "gettimeofday failed");
-+	}
-+
-+	d = ((duk_double_t) tv.tv_sec) * 1000.0 +
-+	    ((duk_double_t) (tv.tv_usec / 1000));
-+	DUK_ASSERT(DUK_FLOOR(d) == d);  /* no fractions */
-+
-+	return d;
-+}
-+#endif  /* DUK_USE_DATE_NOW_GETTIMEOFDAY */
-+
-+#ifdef DUK_USE_DATE_NOW_TIME
-+/* Not a very good provider: only full seconds are available. */
-+DUK_INTERNAL duk_double_t duk_bi_date_get_now(duk_context *ctx) {
-+	time_t t = time(NULL);
-+	return ((duk_double_t) t) * 1000.0;
-+}
-+#endif  /* DUK_USE_DATE_NOW_TIME */
-+
-+#if defined(DUK_USE_DATE_NOW_WINDOWS) || defined(DUK_USE_DATE_TZO_WINDOWS)
-+/* Shared Windows helpers. */
-+DUK_LOCAL void duk__convert_systime_to_ularge(const SYSTEMTIME *st, ULARGE_INTEGER *res) {
-+	FILETIME ft;
-+	if (SystemTimeToFileTime(st, &ft) == 0) {
-+		DUK_D(DUK_DPRINT("SystemTimeToFileTime() failed, returning 0"));
-+		res->QuadPart = 0;
-+	} else {
-+		res->LowPart = ft.dwLowDateTime;
-+		res->HighPart = ft.dwHighDateTime;
-+	}
-+}
-+DUK_LOCAL void duk__set_systime_jan1970(SYSTEMTIME *st) {
-+	DUK_MEMZERO((void *) st, sizeof(*st));
-+	st->wYear = 1970;
-+	st->wMonth = 1;
-+	st->wDayOfWeek = 4;  /* not sure whether or not needed; Thursday */
-+	st->wDay = 1;
-+	DUK_ASSERT(st->wHour == 0);
-+	DUK_ASSERT(st->wMinute == 0);
-+	DUK_ASSERT(st->wSecond == 0);
-+	DUK_ASSERT(st->wMilliseconds == 0);
-+}
-+#endif  /* defined(DUK_USE_DATE_NOW_WINDOWS) || defined(DUK_USE_DATE_TZO_WINDOWS) */
-+
-+#ifdef DUK_USE_DATE_NOW_WINDOWS
-+DUK_INTERNAL duk_double_t duk_bi_date_get_now(duk_context *ctx) {
-+	/* Suggested step-by-step method from documentation of RtlTimeToSecondsSince1970:
-+	 * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724928(v=vs.85).aspx
-+	 */
-+	SYSTEMTIME st1, st2;
-+	ULARGE_INTEGER tmp1, tmp2;
-+
-+	DUK_UNREF(ctx);
-+
-+	GetSystemTime(&st1);
-+	duk__convert_systime_to_ularge((const SYSTEMTIME *) &st1, &tmp1);
-+
-+	duk__set_systime_jan1970(&st2);
-+	duk__convert_systime_to_ularge((const SYSTEMTIME *) &st2, &tmp2);
-+
-+	/* Difference is in 100ns units, convert to milliseconds w/o fractions */
-+	return (duk_double_t) ((tmp1.QuadPart - tmp2.QuadPart) / 10000LL);
-+}
-+#endif  /* DUK_USE_DATE_NOW_WINDOWS */
-+
-+#if defined(DUK_USE_DATE_TZO_GMTIME) || defined(DUK_USE_DATE_TZO_GMTIME_R)
-+/* Get local time offset (in seconds) for a certain (UTC) instant 'd'. */
-+DUK_LOCAL duk_int_t duk__get_local_tzoffset(duk_double_t d) {
-+	time_t t, t1, t2;
-+	duk_int_t parts[DUK__NUM_PARTS];
-+	duk_double_t dparts[DUK__NUM_PARTS];
-+	struct tm tms[2];
-+#ifdef DUK_USE_DATE_TZO_GMTIME
-+	struct tm *tm_ptr;
-+#endif
-+
-+	/* For NaN/inf, the return value doesn't matter. */
-+	if (!DUK_ISFINITE(d)) {
-+		return 0;
-+	}
-+
-+	/* If not within Ecmascript range, some integer time calculations
-+	 * won't work correctly (and some asserts will fail), so bail out
-+	 * if so.  This fixes test-bug-date-insane-setyear.js.  There is
-+	 * a +/- 24h leeway in this range check to avoid a test262 corner
-+	 * case documented in test-bug-date-timeval-edges.js.
-+	 */
-+	if (!duk__timeval_in_leeway_range(d)) {
-+		DUK_DD(DUK_DDPRINT("timeval not within valid range, skip tzoffset computation to avoid integer overflows"));
-+		return 0;
-+	}
-+
-+	/*
-+	 *  This is a bit tricky to implement portably.  The result depends
-+	 *  on the timestamp (specifically, DST depends on the timestamp).
-+	 *  If e.g. UNIX APIs are used, they'll have portability issues with
-+	 *  very small and very large years.
-+	 *
-+	 *  Current approach:
-+	 *
-+	 *  - Stay within portable UNIX limits by using equivalent year mapping.
-+	 *    Avoid year 1970 and 2038 as some conversions start to fail, at
-+	 *    least on some platforms.  Avoiding 1970 means that there are
-+	 *    currently DST discrepancies for 1970.
-+	 *
-+	 *  - Create a UTC and local time breakdowns from 't'.  Then create
-+	 *    a time_t using gmtime() and localtime() and compute the time
-+	 *    difference between the two.
-+	 *
-+	 *  Equivalent year mapping (E5 Section 15.9.1.8):
-+	 *
-+	 *    If the host environment provides functionality for determining
-+	 *    daylight saving time, the implementation of ECMAScript is free
-+	 *    to map the year in question to an equivalent year (same
-+	 *    leap-year-ness and same starting week day for the year) for which
-+	 *    the host environment provides daylight saving time information.
-+	 *    The only restriction is that all equivalent years should produce
-+	 *    the same result.
-+	 *
-+	 *  This approach is quite reasonable but not entirely correct, e.g.
-+	 *  the specification also states (E5 Section 15.9.1.8):
-+	 *
-+	 *    The implementation of ECMAScript should not try to determine
-+	 *    whether the exact time was subject to daylight saving time, but
-+	 *    just whether daylight saving time would have been in effect if
-+	 *    the _current daylight saving time algorithm_ had been used at the
-+	 *    time.  This avoids complications such as taking into account the
-+	 *    years that the locale observed daylight saving time year round.
-+	 *
-+	 *  Since we rely on the platform APIs for conversions between local
-+	 *  time and UTC, we can't guarantee the above.  Rather, if the platform
-+	 *  has historical DST rules they will be applied.  This seems to be the
-+	 *  general preferred direction in Ecmascript standardization (or at least
-+	 *  implementations) anyway, and even the equivalent year mapping should
-+	 *  be disabled if the platform is known to handle DST properly for the
-+	 *  full Ecmascript range.
-+	 *
-+	 *  The following has useful discussion and links:
-+	 *
-+	 *    https://bugzilla.mozilla.org/show_bug.cgi?id=351066
-+	 */
-+
-+	duk__timeval_to_parts(d, parts, dparts, DUK__FLAG_EQUIVYEAR /*flags*/);
-+	DUK_ASSERT(parts[DUK__IDX_YEAR] >= 1970 && parts[DUK__IDX_YEAR] <= 2038);
-+
-+	d = duk__get_timeval_from_dparts(dparts, 0 /*flags*/);
-+	DUK_ASSERT(d >= 0 && d < 2147483648.0 * 1000.0);  /* unsigned 31-bit range */
-+	t = (time_t) (d / 1000.0);
-+	DUK_DDD(DUK_DDDPRINT("timeval: %lf -> time_t %ld", (double) d, (long) t));
-+
-+	t1 = t;
-+
-+	DUK_MEMZERO((void *) tms, sizeof(struct tm) * 2);
-+
-+#if defined(DUK_USE_DATE_TZO_GMTIME_R)
-+	(void) gmtime_r(&t, &tms[0]);
-+	(void) localtime_r(&t, &tms[1]);
-+#elif defined(DUK_USE_DATE_TZO_GMTIME)
-+	tm_ptr = gmtime(&t);
-+	DUK_MEMCPY((void *) &tms[0], tm_ptr, sizeof(struct tm));
-+	tm_ptr = localtime(&t);
-+	DUK_MEMCPY((void *) &tms[1], tm_ptr, sizeof(struct tm));
-+#else
-+#error internal error
-+#endif
-+	DUK_DDD(DUK_DDDPRINT("gmtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld,"
-+	                     "wday:%ld,yday:%ld,isdst:%ld}",
-+	                     (long) tms[0].tm_sec, (long) tms[0].tm_min, (long) tms[0].tm_hour,
-+	                     (long) tms[0].tm_mday, (long) tms[0].tm_mon, (long) tms[0].tm_year,
-+	                     (long) tms[0].tm_wday, (long) tms[0].tm_yday, (long) tms[0].tm_isdst));
-+	DUK_DDD(DUK_DDDPRINT("localtime result: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld,"
-+	                     "wday:%ld,yday:%ld,isdst:%ld}",
-+	                     (long) tms[1].tm_sec, (long) tms[1].tm_min, (long) tms[1].tm_hour,
-+	                     (long) tms[1].tm_mday, (long) tms[1].tm_mon, (long) tms[1].tm_year,
-+	                     (long) tms[1].tm_wday, (long) tms[1].tm_yday, (long) tms[1].tm_isdst));
-+
-+	t1 = mktime(&tms[0]);  /* UTC */
-+	t2 = mktime(&tms[1]);  /* local */
-+	if (t1 == (time_t) -1 || t2 == (time_t) -1) {
-+		/* This check used to be for (t < 0) but on some platforms
-+		 * time_t is unsigned and apparently the proper way to detect
-+		 * an mktime() error return is the cast above.  See e.g.:
-+		 * http://pubs.opengroup.org/onlinepubs/009695299/functions/mktime.html
-+		 */
-+		goto error;
-+	}
-+	if (tms[1].tm_isdst > 0) {
-+		t2 += 3600;
-+	} else if (tms[1].tm_isdst < 0) {
-+		DUK_D(DUK_DPRINT("tm_isdst is negative: %d", (int) tms[1].tm_isdst));
-+	}
-+	DUK_DDD(DUK_DDDPRINT("t1=%ld (utc), t2=%ld (local)", (long) t1, (long) t2));
-+
-+	/* Compute final offset in seconds, positive if local time ahead of
-+	 * UTC (returned value is UTC-to-local offset).
-+	 *
-+	 * difftime() returns a double, so coercion to int generates quite
-+	 * a lot of code.  Direct subtraction is not portable, however.
-+	 * XXX: allow direct subtraction on known platforms.
-+	 */
-+#if 0
-+	return (duk_int_t) (t2 - t1);
-+#endif
-+	return (duk_int_t) difftime(t2, t1);
-+
-+ error:
-+	/* XXX: return something more useful, so that caller can throw? */
-+	DUK_D(DUK_DPRINT("mktime() failed, d=%lf", (double) d));
-+	return 0;
-+}
-+#endif  /* DUK_USE_DATE_TZO_GMTIME */
-+
-+#if defined(DUK_USE_DATE_TZO_WINDOWS)
-+DUK_LOCAL duk_int_t duk__get_local_tzoffset(duk_double_t d) {
-+	SYSTEMTIME st1;
-+	SYSTEMTIME st2;
-+	SYSTEMTIME st3;
-+	ULARGE_INTEGER tmp1;
-+	ULARGE_INTEGER tmp2;
-+	ULARGE_INTEGER tmp3;
-+	FILETIME ft1;
-+
-+	/* XXX: handling of timestamps outside Windows supported range.
-+	 * How does Windows deal with dates before 1600?  Does windows
-+	 * support all Ecmascript years (like -200000 and +200000)?
-+	 * Should equivalent year mapping be used here too?  If so, use
-+	 * a shared helper (currently integrated into timeval-to-parts).
-+	 */
-+
-+	/* Use the approach described in "Remarks" of FileTimeToLocalFileTime:
-+	 * http://msdn.microsoft.com/en-us/library/windows/desktop/ms724277(v=vs.85).aspx
-+	 */
-+
-+	duk__set_systime_jan1970(&st1);
-+	duk__convert_systime_to_ularge((const SYSTEMTIME *) &st1, &tmp1);
-+	tmp2.QuadPart = (ULONGLONG) (d * 10000.0);  /* millisec -> 100ns units since jan 1, 1970 */
-+	tmp2.QuadPart += tmp1.QuadPart;             /* input 'd' in Windows UTC, 100ns units */
-+
-+	ft1.dwLowDateTime = tmp2.LowPart;
-+	ft1.dwHighDateTime = tmp2.HighPart;
-+	FileTimeToSystemTime((const FILETIME *) &ft1, &st2);
-+	if (SystemTimeToTzSpecificLocalTime((LPTIME_ZONE_INFORMATION) NULL, &st2, &st3) == 0) {
-+		DUK_D(DUK_DPRINT("SystemTimeToTzSpecificLocalTime() failed, return tzoffset 0"));
-+		return 0;
-+	}
-+	duk__convert_systime_to_ularge((const SYSTEMTIME *) &st3, &tmp3);
-+
-+	/* Positive if local time ahead of UTC. */
-+	return (duk_int_t) (((LONGLONG) tmp3.QuadPart - (LONGLONG) tmp2.QuadPart) / 10000000LL);  /* seconds */
-+}
-+#endif  /* DUK_USE_DATE_TZO_WINDOWS */
-+
-+#ifdef DUK_USE_DATE_PRS_STRPTIME
-+DUK_LOCAL duk_bool_t duk__parse_string_strptime(duk_context *ctx, const char *str) {
-+	struct tm tm;
-+	time_t t;
-+	char buf[DUK__STRPTIME_BUF_SIZE];
-+
-+	/* copy to buffer with spare to avoid Valgrind gripes from strptime */
-+	DUK_ASSERT(str != NULL);
-+	DUK_MEMZERO(buf, sizeof(buf));  /* valgrind whine without this */
-+	DUK_SNPRINTF(buf, sizeof(buf), "%s", (const char *) str);
-+	buf[sizeof(buf) - 1] = (char) 0;
-+
-+	DUK_DDD(DUK_DDDPRINT("parsing: '%s'", (const char *) buf));
-+
-+	DUK_MEMZERO(&tm, sizeof(tm));
-+	if (strptime((const char *) buf, "%c", &tm) != NULL) {
-+		DUK_DDD(DUK_DDDPRINT("before mktime: tm={sec:%ld,min:%ld,hour:%ld,mday:%ld,mon:%ld,year:%ld,"
-+		                     "wday:%ld,yday:%ld,isdst:%ld}",
-+		                     (long) tm.tm_sec, (long) tm.tm_min, (long) tm.tm_hour,
-+		                     (long) tm.tm_mday, (long) tm.tm_mon, (long) tm.tm_year,
-+		                     (long) tm.tm_wday, (long) tm.tm_yday, (long) tm.tm_isdst));
-+		tm.tm_isdst = -1;  /* negative: dst info not available */
-+
-+		t = mktime(&tm);
-+		DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t));
-+		if (t >= 0) {
-+			duk_push_number(ctx, ((duk_double_t) t) * 1000.0);
-+			return 1;
-+		}
-+	}
-+
-+	return 0;
-+}
-+#endif  /* DUK_USE_DATE_PRS_STRPTIME */
-+
-+#ifdef DUK_USE_DATE_PRS_GETDATE
-+DUK_LOCAL duk_bool_t duk__parse_string_getdate(duk_context *ctx, const char *str) {
-+	struct tm tm;
-+	duk_small_int_t rc;
-+	time_t t;
-+
-+	/* For this to work, DATEMSK must be set, so this is not very
-+	 * convenient for an embeddable interpreter.
-+	 */
-+
-+	DUK_MEMZERO(&tm, sizeof(struct tm));
-+	rc = (duk_small_int_t) getdate_r(str, &tm);
-+	DUK_DDD(DUK_DDDPRINT("getdate_r() -> %ld", (long) rc));
-+
-+	if (rc == 0) {
-+		t = mktime(&tm);
-+		DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t));
-+		if (t >= 0) {
-+			duk_push_number(ctx, (duk_double_t) t);
-+			return 1;
-+		}
-+	}
-+
-+	return 0;
-+}
-+#endif  /* DUK_USE_DATE_PRS_GETDATE */
-+
-+#ifdef DUK_USE_DATE_FMT_STRFTIME
-+DUK_LOCAL duk_bool_t duk__format_parts_strftime(duk_context *ctx, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags) {
-+	char buf[DUK__STRFTIME_BUF_SIZE];
-+	struct tm tm;
-+	const char *fmt;
-+
-+	DUK_UNREF(tzoffset);
-+
-+	/* If the platform doesn't support the entire Ecmascript range, we need
-+	 * to return 0 so that the caller can fall back to the default formatter.
-+	 *
-+	 * For now, assume that if time_t is 8 bytes or more, the whole Ecmascript
-+	 * range is supported.  For smaller time_t values (4 bytes in practice),
-+	 * assumes that the signed 32-bit range is supported.
-+	 *
-+	 * XXX: detect this more correctly per platform.  The size of time_t is
-+	 * probably not an accurate guarantee of strftime() supporting or not
-+	 * supporting a large time range (the full Ecmascript range).
-+	 */
-+	if (sizeof(time_t) < 8 &&
-+	   (parts[DUK__IDX_YEAR] < 1970 || parts[DUK__IDX_YEAR] > 2037)) {
-+		/* be paranoid for 32-bit time values (even avoiding negative ones) */
-+		return 0;
-+	}
-+
-+	DUK_MEMZERO(&tm, sizeof(tm));
-+	tm.tm_sec = parts[DUK__IDX_SECOND];
-+	tm.tm_min = parts[DUK__IDX_MINUTE];
-+	tm.tm_hour = parts[DUK__IDX_HOUR];
-+	tm.tm_mday = parts[DUK__IDX_DAY];       /* already one-based */
-+	tm.tm_mon = parts[DUK__IDX_MONTH] - 1;  /* one-based -> zero-based */
-+	tm.tm_year = parts[DUK__IDX_YEAR] - 1900;
-+	tm.tm_wday = parts[DUK__IDX_WEEKDAY];
-+	tm.tm_isdst = 0;
-+
-+	DUK_MEMZERO(buf, sizeof(buf));
-+	if ((flags & DUK__FLAG_TOSTRING_DATE) && (flags & DUK__FLAG_TOSTRING_TIME)) {
-+		fmt = "%c";
-+	} else if (flags & DUK__FLAG_TOSTRING_DATE) {
-+		fmt = "%x";
-+	} else {
-+		DUK_ASSERT(flags & DUK__FLAG_TOSTRING_TIME);
-+		fmt = "%X";
-+	}
-+	(void) strftime(buf, sizeof(buf) - 1, fmt, &tm);
-+	DUK_ASSERT(buf[sizeof(buf) - 1] == 0);
-+
-+	duk_push_string(ctx, buf);
-+	return 1;
-+}
-+#endif  /* DUK_USE_DATE_FMT_STRFTIME */
-+
-+/*
-+ *  ISO 8601 subset parser.
-+ */
-+
-+/* Parser part count. */
-+#define DUK__NUM_ISO8601_PARSER_PARTS  9
-+
-+/* Parser part indices. */
-+#define DUK__PI_YEAR         0
-+#define DUK__PI_MONTH        1
-+#define DUK__PI_DAY          2
-+#define DUK__PI_HOUR         3
-+#define DUK__PI_MINUTE       4
-+#define DUK__PI_SECOND       5
-+#define DUK__PI_MILLISECOND  6
-+#define DUK__PI_TZHOUR       7
-+#define DUK__PI_TZMINUTE     8
-+
-+/* Parser part masks. */
-+#define DUK__PM_YEAR         (1 << DUK__PI_YEAR)
-+#define DUK__PM_MONTH        (1 << DUK__PI_MONTH)
-+#define DUK__PM_DAY          (1 << DUK__PI_DAY)
-+#define DUK__PM_HOUR         (1 << DUK__PI_HOUR)
-+#define DUK__PM_MINUTE       (1 << DUK__PI_MINUTE)
-+#define DUK__PM_SECOND       (1 << DUK__PI_SECOND)
-+#define DUK__PM_MILLISECOND  (1 << DUK__PI_MILLISECOND)
-+#define DUK__PM_TZHOUR       (1 << DUK__PI_TZHOUR)
-+#define DUK__PM_TZMINUTE     (1 << DUK__PI_TZMINUTE)
-+
-+/* Parser separator indices. */
-+#define DUK__SI_PLUS         0
-+#define DUK__SI_MINUS        1
-+#define DUK__SI_T            2
-+#define DUK__SI_SPACE        3
-+#define DUK__SI_COLON        4
-+#define DUK__SI_PERIOD       5
-+#define DUK__SI_Z            6
-+#define DUK__SI_NUL          7
-+
-+/* Parser separator masks. */
-+#define DUK__SM_PLUS         (1 << DUK__SI_PLUS)
-+#define DUK__SM_MINUS        (1 << DUK__SI_MINUS)
-+#define DUK__SM_T            (1 << DUK__SI_T)
-+#define DUK__SM_SPACE        (1 << DUK__SI_SPACE)
-+#define DUK__SM_COLON        (1 << DUK__SI_COLON)
-+#define DUK__SM_PERIOD       (1 << DUK__SI_PERIOD)
-+#define DUK__SM_Z            (1 << DUK__SI_Z)
-+#define DUK__SM_NUL          (1 << DUK__SI_NUL)
-+
-+/* Rule control flags. */
-+#define DUK__CF_NEG          (1 << 0)  /* continue matching, set neg_tzoffset flag */
-+#define DUK__CF_ACCEPT       (1 << 1)  /* accept string */
-+#define DUK__CF_ACCEPT_NUL   (1 << 2)  /* accept string if next char is NUL (otherwise reject) */
-+
-+#define DUK__PACK_RULE(partmask,sepmask,nextpart,flags)  \
-+	((duk_uint32_t) (partmask) + \
-+	 (((duk_uint32_t) (sepmask)) << 9) + \
-+	 (((duk_uint32_t) (nextpart)) << 17) + \
-+	 (((duk_uint32_t) (flags)) << 21))
-+
-+#define DUK__UNPACK_RULE(rule,var_nextidx,var_flags)  do { \
-+		(var_nextidx) = (duk_small_uint_t) (((rule) >> 17) & 0x0f); \
-+		(var_flags) = (duk_small_uint_t) ((rule) >> 21); \
-+	} while (0)
-+
-+#define DUK__RULE_MASK_PART_SEP  0x1ffffUL
-+
-+/* Matching separator index is used in the control table */
-+DUK_LOCAL const duk_uint8_t duk__parse_iso8601_seps[] = {
-+	DUK_ASC_PLUS /*0*/, DUK_ASC_MINUS /*1*/, DUK_ASC_UC_T /*2*/, DUK_ASC_SPACE /*3*/,
-+	DUK_ASC_COLON /*4*/, DUK_ASC_PERIOD /*5*/, DUK_ASC_UC_Z /*6*/, DUK_ASC_NUL /*7*/
-+};
-+
-+/* Rule table: first matching rule is used to determine what to do next. */
-+DUK_LOCAL const duk_uint32_t duk__parse_iso8601_control[] = {
-+	DUK__PACK_RULE(DUK__PM_YEAR, DUK__SM_MINUS, DUK__PI_MONTH, 0),
-+	DUK__PACK_RULE(DUK__PM_MONTH, DUK__SM_MINUS, DUK__PI_DAY, 0),
-+	DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY, DUK__SM_T | DUK__SM_SPACE, DUK__PI_HOUR, 0),
-+	DUK__PACK_RULE(DUK__PM_HOUR, DUK__SM_COLON, DUK__PI_MINUTE, 0),
-+	DUK__PACK_RULE(DUK__PM_MINUTE, DUK__SM_COLON, DUK__PI_SECOND, 0),
-+	DUK__PACK_RULE(DUK__PM_SECOND, DUK__SM_PERIOD, DUK__PI_MILLISECOND, 0),
-+	DUK__PACK_RULE(DUK__PM_TZHOUR, DUK__SM_COLON, DUK__PI_TZMINUTE, 0),
-+	DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR /*Note1*/ | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_PLUS, DUK__PI_TZHOUR, 0),
-+	DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR /*Note1*/ | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_MINUS, DUK__PI_TZHOUR, DUK__CF_NEG),
-+	DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR /*Note1*/ | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND, DUK__SM_Z, 0, DUK__CF_ACCEPT_NUL),
-+	DUK__PACK_RULE(DUK__PM_YEAR | DUK__PM_MONTH | DUK__PM_DAY | DUK__PM_HOUR /*Note1*/ | DUK__PM_MINUTE | DUK__PM_SECOND | DUK__PM_MILLISECOND | DUK__PM_TZHOUR /*Note2*/ | DUK__PM_TZMINUTE, DUK__SM_NUL, 0, DUK__CF_ACCEPT)
-+
-+	/* Note1: the specification doesn't require matching a time form with
-+	 *        just hours ("HH"), but we accept it here, e.g. "2012-01-02T12Z".
-+	 *
-+	 * Note2: the specification doesn't require matching a timezone offset
-+	 *        with just hours ("HH"), but accept it here, e.g. "2012-01-02T03:04:05+02"
-+	 */
-+};
-+
-+DUK_LOCAL duk_bool_t duk__parse_string_iso8601_subset(duk_context *ctx, const char *str) {
-+	duk_int_t parts[DUK__NUM_ISO8601_PARSER_PARTS];
-+	duk_double_t dparts[DUK__NUM_PARTS];
-+	duk_double_t d;
-+	const duk_uint8_t *p;
-+	duk_small_uint_t part_idx = 0;
-+	duk_int_t accum = 0;
-+	duk_small_uint_t ndigits = 0;
-+	duk_bool_t neg_year = 0;
-+	duk_bool_t neg_tzoffset = 0;
-+	duk_uint_fast8_t ch;
-+	duk_small_uint_t i;
-+
-+	/* During parsing, month and day are one-based; set defaults here. */
-+	DUK_MEMZERO(parts, sizeof(parts));
-+	DUK_ASSERT(parts[DUK__IDX_YEAR] == 0);  /* don't care value, year is mandatory */
-+	parts[DUK__IDX_MONTH] = 1;
-+	parts[DUK__IDX_DAY] = 1;
-+
-+	/* Special handling for year sign. */
-+	p = (const duk_uint8_t *) str;
-+	ch = p[0];
-+	if (ch == DUK_ASC_PLUS) {
-+		p++;
-+	} else if (ch == DUK_ASC_MINUS) {
-+		neg_year = 1;
-+		p++;
-+	}
-+
-+	for (;;) {
-+		ch = *p++;
-+		DUK_DDD(DUK_DDDPRINT("parsing, part_idx=%ld, char=%ld ('%c')",
-+		                     (long) part_idx, (long) ch,
-+		                     (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : DUK_ASC_QUESTION)));
-+
-+		if (ch >= DUK_ASC_0 && ch <= DUK_ASC_9) {
-+			if (ndigits >= 9) {
-+				DUK_DDD(DUK_DDDPRINT("too many digits -> reject"));
-+				goto reject;
-+			}
-+			if (part_idx == DUK__PI_MILLISECOND /*msec*/ && ndigits >= 3) {
-+				/* ignore millisecond fractions after 3 */
-+			} else {
-+				accum = accum * 10 + ((duk_int_t) ch) - ((duk_int_t) DUK_ASC_0) + 0x00;
-+				ndigits++;
-+			}
-+		} else {
-+			duk_uint_fast32_t match_val;
-+			duk_small_int_t sep_idx;
-+
-+			if (ndigits <= 0) {
-+				goto reject;
-+			}
-+			if (part_idx == DUK__PI_MILLISECOND) {
-+				/* complete the millisecond field */
-+				while (ndigits < 3) {
-+					accum *= 10;
-+					ndigits++;
-+				}
-+			}
-+			parts[part_idx] = accum;
-+			DUK_DDD(DUK_DDDPRINT("wrote part %ld -> value %ld", (long) part_idx, (long) accum));
-+
-+			accum = 0;
-+			ndigits = 0;
-+
-+			for (i = 0; i < (duk_small_uint_t) (sizeof(duk__parse_iso8601_seps) / sizeof(duk_uint8_t)); i++) {
-+				if (duk__parse_iso8601_seps[i] == ch) {
-+					break;
-+				}
-+			}
-+			if (i == (duk_small_uint_t) (sizeof(duk__parse_iso8601_seps) / sizeof(duk_uint8_t))) {
-+				DUK_DDD(DUK_DDDPRINT("separator character doesn't match -> reject"));
-+				goto reject;
-+			}
-+
-+			sep_idx = i;
-+			match_val = (1UL << part_idx) + (1UL << (sep_idx + 9));  /* match against rule part/sep bits */
-+
-+			for (i = 0; i < (duk_small_uint_t) (sizeof(duk__parse_iso8601_control) / sizeof(duk_uint32_t)); i++) {
-+				duk_uint_fast32_t rule = duk__parse_iso8601_control[i];
-+				duk_small_uint_t nextpart;
-+				duk_small_uint_t cflags;
-+
-+				DUK_DDD(DUK_DDDPRINT("part_idx=%ld, sep_idx=%ld, match_val=0x%08lx, considering rule=0x%08lx",
-+				                     (long) part_idx, (long) sep_idx,
-+				                     (unsigned long) match_val, (unsigned long) rule));
-+
-+				if ((rule & match_val) != match_val) {
-+					continue;
-+				}
-+
-+				DUK__UNPACK_RULE(rule, nextpart, cflags);
-+
-+				DUK_DDD(DUK_DDDPRINT("rule match -> part_idx=%ld, sep_idx=%ld, match_val=0x%08lx, "
-+				                     "rule=0x%08lx -> nextpart=%ld, cflags=0x%02lx",
-+				                     (long) part_idx, (long) sep_idx,
-+				                     (unsigned long) match_val, (unsigned long) rule,
-+				                     (long) nextpart, (unsigned long) cflags));
-+
-+				if (cflags & DUK__CF_NEG) {
-+					neg_tzoffset = 1;
-+				}
-+
-+				if (cflags & DUK__CF_ACCEPT) {
-+					goto accept;
-+				}
-+
-+				if (cflags & DUK__CF_ACCEPT_NUL) {
-+					DUK_ASSERT(*(p - 1) != (char) 0);
-+					if (*p == DUK_ASC_NUL) {
-+						goto accept;
-+					}
-+					goto reject;
-+				}
-+
-+				part_idx = nextpart;
-+				break;
-+			}  /* rule match */
-+
-+			if (i == (duk_small_uint_t) (sizeof(duk__parse_iso8601_control) / sizeof(duk_uint32_t))) {
-+				DUK_DDD(DUK_DDDPRINT("no rule matches -> reject"));
-+				goto reject;
-+			}
-+
-+			if (ch == 0) {
-+				/* This shouldn't be necessary, but check just in case
-+				 * to avoid any chance of overruns.
-+				 */
-+				DUK_DDD(DUK_DDDPRINT("NUL after rule matching (should not happen) -> reject"));
-+				goto reject;
-+			}
-+		}  /* if-digit-else-ctrl */
-+	}  /* char loop */
-+
-+	/* We should never exit the loop above, but if we do, reject
-+	 * by falling through.
-+	 */
-+	DUK_DDD(DUK_DDDPRINT("fell out of char loop without explicit accept/reject -> reject"));
-+
-+ reject:
-+	DUK_DDD(DUK_DDDPRINT("reject"));
-+	return 0;
-+
-+ accept:
-+	DUK_DDD(DUK_DDDPRINT("accept"));
-+
-+	/* Apply timezone offset to get the main parts in UTC */
-+	if (neg_year) {
-+		parts[DUK__PI_YEAR] = -parts[DUK__PI_YEAR];
-+	}
-+	if (neg_tzoffset) {
-+		parts[DUK__PI_HOUR] += parts[DUK__PI_TZHOUR];
-+		parts[DUK__PI_MINUTE] += parts[DUK__PI_TZMINUTE];
-+	} else {
-+		parts[DUK__PI_HOUR] -= parts[DUK__PI_TZHOUR];
-+		parts[DUK__PI_MINUTE] -= parts[DUK__PI_TZMINUTE];
-+	}
-+	parts[DUK__PI_MONTH] -= 1;  /* zero-based month */
-+	parts[DUK__PI_DAY] -= 1;  /* zero-based day */
-+
-+	/* Use double parts, they tolerate unnormalized time.
-+	 *
-+	 * Note: DUK__IDX_WEEKDAY is initialized with a bogus value (DUK__PI_TZHOUR)
-+	 * on purpose.  It won't be actually used by duk__get_timeval_from_dparts(),
-+	 * but will make the value initialized just in case, and avoid any
-+	 * potential for Valgrind issues.
-+	 */
-+	for (i = 0; i < DUK__NUM_PARTS; i++) {
-+		DUK_DDD(DUK_DDDPRINT("part[%ld] = %ld", (long) i, (long) parts[i]));
-+		dparts[i] = parts[i];
-+	}
-+
-+	d = duk__get_timeval_from_dparts(dparts, 0 /*flags*/);
-+	duk_push_number(ctx, d);
-+	return 1;
-+}
-+
-+/*
-+ *  Date/time parsing helper.
-+ *
-+ *  Parse a datetime string into a time value.  We must first try to parse
-+ *  the input according to the standard format in E5.1 Section 15.9.1.15.
-+ *  If that fails, we can try to parse using custom parsing, which can
-+ *  either be platform neutral (custom code) or platform specific (using
-+ *  existing platform API calls).
-+ *
-+ *  Note in particular that we must parse whatever toString(), toUTCString(),
-+ *  and toISOString() can produce; see E5.1 Section 15.9.4.2.
-+ *
-+ *  Returns 1 to allow tailcalling.
-+ *
-+ *  There is much room for improvement here with respect to supporting
-+ *  alternative datetime formats.  For instance, V8 parses '2012-01-01' as
-+ *  UTC and '2012/01/01' as local time.
-+ */
-+
-+DUK_LOCAL duk_ret_t duk__parse_string(duk_context *ctx, const char *str) {
-+	/* XXX: there is a small risk here: because the ISO 8601 parser is
-+	 * very loose, it may end up parsing some datetime values which
-+	 * would be better parsed with a platform specific parser.
-+	 */
-+
-+	DUK_ASSERT(str != NULL);
-+	DUK_DDD(DUK_DDDPRINT("parse datetime from string '%s'", (const char *) str));
-+
-+	if (duk__parse_string_iso8601_subset(ctx, str) != 0) {
-+		return 1;
-+	}
-+
-+#if defined(DUK_USE_DATE_PRS_STRPTIME)
-+	if (duk__parse_string_strptime(ctx, str) != 0) {
-+		return 1;
-+	}
-+#elif defined(DUK_USE_DATE_PRS_GETDATE)
-+	if (duk__parse_string_getdate(ctx, str) != 0) {
-+		return 1;
-+	}
-+#else
-+	/* No platform-specific parsing, this is not an error. */
-+#endif
-+
-+	duk_push_nan(ctx);
-+	return 1;
-+}
-+
-+/*
-+ *  Calendar helpers
-+ *
-+ *  Some helpers are used for getters and can operate on normalized values
-+ *  which can be represented with 32-bit signed integers.  Other helpers are
-+ *  needed by setters and operate on un-normalized double values, must watch
-+ *  out for non-finite numbers etc.
-+ */
-+
-+DUK_LOCAL duk_uint8_t duk__days_in_month[12] = {
-+	(duk_uint8_t) 31, (duk_uint8_t) 28, (duk_uint8_t) 31, (duk_uint8_t) 30,
-+	(duk_uint8_t) 31, (duk_uint8_t) 30, (duk_uint8_t) 31, (duk_uint8_t) 31,
-+	(duk_uint8_t) 30, (duk_uint8_t) 31, (duk_uint8_t) 30, (duk_uint8_t) 31
-+};
-+
-+/* Maximum iteration count for computing UTC-to-local time offset when
-+ * creating an Ecmascript time value from local parts.
-+ */
-+#define DUK__LOCAL_TZOFFSET_MAXITER   4
-+
-+/* Because 'day since epoch' can be negative and is used to compute weekday
-+ * using a modulo operation, add this multiple of 7 to avoid negative values
-+ * when year is below 1970 epoch.  Ecmascript time values are restricted to
-+ * +/- 100 million days from epoch, so this adder fits nicely into 32 bits.
-+ * Round to a multiple of 7 (= floor(100000000 / 7) * 7) and add margin.
-+ */
-+#define DUK__WEEKDAY_MOD_ADDER  (20000000 * 7)  /* 0x08583b00 */
-+
-+DUK_LOCAL duk_bool_t duk__is_leap_year(duk_int_t year) {
-+	if ((year % 4) != 0) {
-+		return 0;
-+	}
-+	if ((year % 100) != 0) {
-+		return 1;
-+	}
-+	if ((year % 400) != 0) {
-+		return 0;
-+	}
-+	return 1;
-+}
-+
-+DUK_LOCAL duk_bool_t duk__timeval_in_valid_range(duk_double_t x) {
-+	return (x >= -DUK__MS_100M_DAYS && x <= DUK__MS_100M_DAYS);
-+}
-+
-+DUK_LOCAL duk_bool_t duk__timeval_in_leeway_range(duk_double_t x) {
-+	return (x >= -DUK__MS_100M_DAYS_LEEWAY && x <= DUK__MS_100M_DAYS_LEEWAY);
-+}
-+
-+DUK_LOCAL duk_bool_t duk__year_in_valid_range(duk_double_t x) {
-+	return (x >= DUK__MIN_ECMA_YEAR && x <= DUK__MAX_ECMA_YEAR);
-+}
-+
-+DUK_LOCAL duk_double_t duk__timeclip(duk_double_t x) {
-+	if (!DUK_ISFINITE(x)) {
-+		return DUK_DOUBLE_NAN;
-+	}
-+
-+	if (!duk__timeval_in_valid_range(x)) {
-+		return DUK_DOUBLE_NAN;
-+	}
-+
-+	x = duk_js_tointeger_number(x);
-+
-+	/* Here we'd have the option to normalize -0 to +0. */
-+	return x;
-+}
-+
-+/* Integer division which floors also negative values correctly. */
-+DUK_LOCAL duk_int_t duk__div_floor(duk_int_t a, duk_int_t b) {
-+	DUK_ASSERT(b > 0);
-+	if (a >= 0) {
-+		return a / b;
-+	} else {
-+		/* e.g. a = -4, b = 5  -->  -4 - 5 + 1 / 5  -->  -8 / 5  -->  -1
-+		 *      a = -5, b = 5  -->  -5 - 5 + 1 / 5  -->  -9 / 5  -->  -1
-+		 *      a = -6, b = 5  -->  -6 - 5 + 1 / 5  -->  -10 / 5  -->  -2
-+		 */
-+		return (a - b + 1) / b;
-+	}
-+}
-+
-+/* Compute day number of the first day of a given year. */
-+DUK_LOCAL duk_int_t duk__day_from_year(duk_int_t year) {
-+	/* Note: in integer arithmetic, (x / 4) is same as floor(x / 4) for non-negative
-+	 * values, but is incorrect for negative ones.
-+	 */
-+	return 365 * (year - 1970)
-+	       + duk__div_floor(year - 1969, 4)
-+	       - duk__div_floor(year - 1901, 100)
-+	       + duk__div_floor(year - 1601, 400);
-+}
-+
-+/* Given a day number, determine year and day-within-year. */
-+DUK_LOCAL duk_int_t duk__year_from_day(duk_int_t day, duk_small_int_t *out_day_within_year) {
-+	duk_int_t year;
-+	duk_int_t diff_days;
-+
-+	/* estimate year upwards (towards positive infinity), then back down;
-+	 * two iterations should be enough
-+	 */
-+
-+	if (day >= 0) {
-+		year = 1970 + day / 365;
-+	} else {
-+		year = 1970 + day / 366;
-+	}
-+
-+	for (;;) {
-+		diff_days = duk__day_from_year(year) - day;
-+		DUK_DDD(DUK_DDDPRINT("year=%ld day=%ld, diff_days=%ld", (long) year, (long) day, (long) diff_days));
-+		if (diff_days <= 0) {
-+			DUK_ASSERT(-diff_days < 366);  /* fits into duk_small_int_t */
-+			*out_day_within_year = -diff_days;
-+			DUK_DDD(DUK_DDDPRINT("--> year=%ld, day-within-year=%ld",
-+			                     (long) year, (long) *out_day_within_year));
-+			DUK_ASSERT(*out_day_within_year >= 0);
-+			DUK_ASSERT(*out_day_within_year < (duk__is_leap_year(year) ? 366 : 365));
-+			return year;
-+		}
-+
-+		/* Note: this is very tricky; we must never 'overshoot' the
-+		 * correction downwards.
-+		 */
-+		year -= 1 + (diff_days - 1) / 366;  /* conservative */
-+	}
-+}
-+
-+/* Given a (year, month, day-within-month) triple, compute day number.
-+ * The input triple is un-normalized and may contain non-finite values.
-+ */
-+DUK_LOCAL duk_double_t duk__make_day(duk_double_t year, duk_double_t month, duk_double_t day) {
-+	duk_int_t day_num;
-+	duk_bool_t is_leap;
-+	duk_small_int_t i, n;
-+
-+	/* Assume that year, month, day are all coerced to whole numbers.
-+	 * They may also be NaN or infinity, in which case this function
-+	 * must return NaN or infinity to ensure time value becomes NaN.
-+	 * If 'day' is NaN, the final return will end up returning a NaN,
-+	 * so it doesn't need to be checked here.
-+	 */
-+
-+	if (!DUK_ISFINITE(year) || !DUK_ISFINITE(month)) {
-+		return DUK_DOUBLE_NAN;
-+	}
-+
-+	year += DUK_FLOOR(month / 12.0);
-+
-+	month = DUK_FMOD(month, 12.0);
-+	if (month < 0.0) {
-+		/* handle negative values */
-+		month += 12.0;
-+	}
-+
-+	/* The algorithm in E5.1 Section 15.9.1.12 normalizes month, but
-+	 * does not normalize the day-of-month (nor check whether or not
-+	 * it is finite) because it's not necessary for finding the day
-+	 * number which matches the (year,month) pair.
-+	 *
-+	 * We assume that duk__day_from_year() is exact here.
-+	 *
-+	 * Without an explicit infinity / NaN check in the beginning,
-+	 * day_num would be a bogus integer here.
-+	 *
-+	 * It's possible for 'year' to be out of integer range here.
-+	 * If so, we need to return NaN without integer overflow.
-+	 * This fixes test-bug-setyear-overflow.js.
-+	 */
-+
-+	if (!duk__year_in_valid_range(year)) {
-+		DUK_DD(DUK_DDPRINT("year not in ecmascript valid range, avoid integer overflow: %lf", (double) year));
-+		return DUK_DOUBLE_NAN;
-+	}
-+	day_num = duk__day_from_year((duk_int_t) year);
-+	is_leap = duk__is_leap_year((duk_int_t) year);
-+
-+	n = (duk_small_int_t) month;
-+	for (i = 0; i < n; i++) {
-+		day_num += duk__days_in_month[i];
-+		if (i == 1 && is_leap) {
-+			day_num++;
-+		}
-+	}
-+
-+	/* If 'day' is NaN, returns NaN. */
-+	return (duk_double_t) day_num + day;
-+}
-+
-+/* Split time value into parts.  The time value is assumed to be an internal
-+ * one, i.e. finite, no fractions.  Possible local time adjustment has already
-+ * been applied when reading the time value.
-+ */
-+DUK_LOCAL void duk__timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags) {
-+	duk_double_t d1, d2;
-+	duk_int_t t1, t2;
-+	duk_int_t day_since_epoch;
-+	duk_int_t year;  /* does not fit into 16 bits */
-+	duk_small_int_t day_in_year;
-+	duk_small_int_t month;
-+	duk_small_int_t day;
-+	duk_small_int_t dim;
-+	duk_int_t jan1_since_epoch;
-+	duk_small_int_t jan1_weekday;
-+	duk_int_t equiv_year;
-+	duk_small_uint_t i;
-+	duk_bool_t is_leap;
-+	duk_small_int_t arridx;
-+
-+	DUK_ASSERT(DUK_ISFINITE(d));    /* caller checks */
-+	DUK_ASSERT(DUK_FLOOR(d) == d);  /* no fractions in internal time */
-+
-+	/* The timevalue must be in valid Ecmascript range, but since a local
-+	 * time offset can be applied, we need to allow a +/- 24h leeway to
-+	 * the value.  In other words, although the UTC time is within the
-+	 * Ecmascript range, the local part values can be just outside of it.
-+	 */
-+	DUK_UNREF(duk__timeval_in_leeway_range);
-+	DUK_ASSERT(duk__timeval_in_leeway_range(d));
-+
-+	/* these computations are guaranteed to be exact for the valid
-+	 * E5 time value range, assuming milliseconds without fractions.
-+	 */
-+	d1 = (duk_double_t) DUK_FMOD(d, (double) DUK__MS_DAY);
-+	if (d1 < 0.0) {
-+		/* deal with negative values */
-+		d1 += (duk_double_t) DUK__MS_DAY;
-+	}
-+	d2 = DUK_FLOOR((double) (d / (duk_double_t) DUK__MS_DAY));
-+	DUK_ASSERT(d2 * ((duk_double_t) DUK__MS_DAY) + d1 == d);
-+	/* now expected to fit into a 32-bit integer */
-+	t1 = (duk_int_t) d1;
-+	t2 = (duk_int_t) d2;
-+	day_since_epoch = t2;
-+	DUK_ASSERT((duk_double_t) t1 == d1);
-+	DUK_ASSERT((duk_double_t) t2 == d2);
-+
-+	/* t1 = milliseconds within day (fits 32 bit)
-+	 * t2 = day number from epoch (fits 32 bit, may be negative)
-+	 */
-+
-+	parts[DUK__IDX_MILLISECOND] = t1 % 1000; t1 /= 1000;
-+	parts[DUK__IDX_SECOND] = t1 % 60; t1 /= 60;
-+	parts[DUK__IDX_MINUTE] = t1 % 60; t1 /= 60;
-+	parts[DUK__IDX_HOUR] = t1;
-+	DUK_ASSERT(parts[DUK__IDX_MILLISECOND] >= 0 && parts[DUK__IDX_MILLISECOND] <= 999);
-+	DUK_ASSERT(parts[DUK__IDX_SECOND] >= 0 && parts[DUK__IDX_SECOND] <= 59);
-+	DUK_ASSERT(parts[DUK__IDX_MINUTE] >= 0 && parts[DUK__IDX_MINUTE] <= 59);
-+	DUK_ASSERT(parts[DUK__IDX_HOUR] >= 0 && parts[DUK__IDX_HOUR] <= 23);
-+
-+	DUK_DDD(DUK_DDDPRINT("d=%lf, d1=%lf, d2=%lf, t1=%ld, t2=%ld, parts: hour=%ld min=%ld sec=%ld msec=%ld",
-+	                     (double) d, (double) d1, (double) d2, (long) t1, (long) t2,
-+	                     (long) parts[DUK__IDX_HOUR],
-+	                     (long) parts[DUK__IDX_MINUTE],
-+	                     (long) parts[DUK__IDX_SECOND],
-+	                     (long) parts[DUK__IDX_MILLISECOND]));
-+
-+	/* This assert depends on the input parts representing time inside
-+	 * the Ecmascript range.
-+	 */
-+	DUK_ASSERT(t2 + DUK__WEEKDAY_MOD_ADDER >= 0);
-+	parts[DUK__IDX_WEEKDAY] = (t2 + 4 + DUK__WEEKDAY_MOD_ADDER) % 7;  /* E5.1 Section 15.9.1.6 */
-+	DUK_ASSERT(parts[DUK__IDX_WEEKDAY] >= 0 && parts[DUK__IDX_WEEKDAY] <= 6);
-+
-+	year = duk__year_from_day(t2, &day_in_year);
-+	day = day_in_year;
-+	is_leap = duk__is_leap_year(year);
-+	for (month = 0; month < 12; month++) {
-+		dim = duk__days_in_month[month];
-+		if (month == 1 && is_leap) {
-+			dim++;
-+		}
-+		DUK_DDD(DUK_DDDPRINT("month=%ld, dim=%ld, day=%ld",
-+		                     (long) month, (long) dim, (long) day));
-+		if (day < dim) {
-+			break;
-+		}
-+		day -= dim;
-+	}
-+	DUK_DDD(DUK_DDDPRINT("final month=%ld", (long) month));
-+	DUK_ASSERT(month >= 0 && month <= 11);
-+	DUK_ASSERT(day >= 0 && day <= 31);
-+
-+	/* Equivalent year mapping, used to avoid DST trouble when platform
-+	 * may fail to provide reasonable DST answers for dates outside the
-+	 * ordinary range (e.g. 1970-2038).  An equivalent year has the same
-+	 * leap-year-ness as the original year and begins on the same weekday
-+	 * (Jan 1).
-+	 *
-+	 * The year 2038 is avoided because there seem to be problems with it
-+	 * on some platforms.  The year 1970 is also avoided as there were
-+	 * practical problems with it; an equivalent year is used for it too,
-+	 * which breaks some DST computations for 1970 right now, see e.g.
-+	 * test-bi-date-tzoffset-brute-fi.js.
-+	 */
-+	if ((flags & DUK__FLAG_EQUIVYEAR) && (year < 1971 || year > 2037)) {
-+		DUK_ASSERT(is_leap == 0 || is_leap == 1);
-+
-+		jan1_since_epoch = day_since_epoch - day_in_year;  /* day number for Jan 1 since epoch */
-+		DUK_ASSERT(jan1_since_epoch + DUK__WEEKDAY_MOD_ADDER >= 0);
-+		jan1_weekday = (jan1_since_epoch + 4 + DUK__WEEKDAY_MOD_ADDER) % 7;  /* E5.1 Section 15.9.1.6 */
-+		DUK_ASSERT(jan1_weekday >= 0 && jan1_weekday <= 6);
-+		arridx = jan1_weekday;
-+		if (is_leap) {
-+			arridx += 7;
-+		}
-+		DUK_ASSERT(arridx >= 0 && arridx < (duk_small_int_t) (sizeof(duk__date_equivyear) / sizeof(duk_uint8_t)));
-+
-+		equiv_year = (duk_int_t) duk__date_equivyear[arridx] + 1970;
-+		year = equiv_year;
-+		DUK_DDD(DUK_DDDPRINT("equiv year mapping, year=%ld, day_in_year=%ld, day_since_epoch=%ld, "
-+		                     "jan1_since_epoch=%ld, jan1_weekday=%ld -> equiv year %ld",
-+		                     (long) year, (long) day_in_year, (long) day_since_epoch,
-+		                     (long) jan1_since_epoch, (long) jan1_weekday, (long) equiv_year));
-+	}
-+
-+	parts[DUK__IDX_YEAR] = year;
-+	parts[DUK__IDX_MONTH] = month;
-+	parts[DUK__IDX_DAY] = day;
-+
-+	if (flags & DUK__FLAG_ONEBASED) {
-+		parts[DUK__IDX_MONTH]++;  /* zero-based -> one-based */
-+		parts[DUK__IDX_DAY]++;    /* -""- */
-+	}
-+
-+	if (dparts != NULL) {
-+		for (i = 0; i < DUK__NUM_PARTS; i++) {
-+			dparts[i] = (duk_double_t) parts[i];
-+		}
-+	}
-+}
-+
-+/* Compute time value from (double) parts.  The parts can be either UTC
-+ * or local time; if local, they need to be (conceptually) converted into
-+ * UTC time.  The parts may represent valid or invalid time, and may be
-+ * wildly out of range (but may cancel each other and still come out in
-+ * the valid Date range).
-+ */
-+DUK_LOCAL duk_double_t duk__get_timeval_from_dparts(duk_double_t *dparts, duk_small_uint_t flags) {
-+#if defined(DUK_USE_PARANOID_DATE_COMPUTATION)
-+	/* See comments below on MakeTime why these are volatile. */
-+	volatile duk_double_t tmp_time;
-+	volatile duk_double_t tmp_day;
-+	volatile duk_double_t d;
-+#else
-+	duk_double_t tmp_time;
-+	duk_double_t tmp_day;
-+	duk_double_t d;
-+#endif
-+	duk_small_uint_t i;
-+	duk_int_t tzoff, tzoffprev1, tzoffprev2;
-+
-+	/* Expects 'this' at top of stack on entry. */
-+
-+	/* Coerce all finite parts with ToInteger().  ToInteger() must not
-+	 * be called for NaN/Infinity because it will convert e.g. NaN to
-+	 * zero.  If ToInteger() has already been called, this has no side
-+	 * effects and is idempotent.
-+	 *
-+	 * Don't read dparts[DUK__IDX_WEEKDAY]; it will cause Valgrind issues
-+	 * if the value is uninitialized.
-+	 */
-+	for (i = 0; i <= DUK__IDX_MILLISECOND; i++) {
-+		/* SCANBUILD: scan-build complains here about assigned value
-+		 * being garbage or undefined.  This is correct but operating
-+		 * on undefined values has no ill effect and is ignored by the
-+		 * caller in the case where this happens.
-+		 */
-+		d = dparts[i];
-+		if (DUK_ISFINITE(d)) {
-+			dparts[i] = duk_js_tointeger_number(d);
-+		}
-+	}
-+
-+	/* Use explicit steps in computation to try to ensure that
-+	 * computation happens with intermediate results coerced to
-+	 * double values (instead of using something more accurate).
-+	 * E.g. E5.1 Section 15.9.1.11 requires use of IEEE 754
-+	 * rules (= Ecmascript '+' and '*' operators).
-+	 *
-+	 * Without 'volatile' even this approach fails on some platform
-+	 * and compiler combinations.  For instance, gcc 4.8.1 on Ubuntu
-+	 * 64-bit, with -m32 and without -std=c99, test-bi-date-canceling.js
-+	 * would fail because of some optimizations when computing tmp_time
-+	 * (MakeTime below).  Adding 'volatile' to tmp_time solved this
-+	 * particular problem (annoyingly, also adding debug prints or
-+	 * running the executable under valgrind hides it).
-+	 */
-+
-+	/* MakeTime */
-+	tmp_time = 0.0;
-+	tmp_time += dparts[DUK__IDX_HOUR] * ((duk_double_t) DUK__MS_HOUR);
-+	tmp_time += dparts[DUK__IDX_MINUTE] * ((duk_double_t) DUK__MS_MINUTE);
-+	tmp_time += dparts[DUK__IDX_SECOND] * ((duk_double_t) DUK__MS_SECOND);
-+	tmp_time += dparts[DUK__IDX_MILLISECOND];
-+
-+	/* MakeDay */
-+	tmp_day = duk__make_day(dparts[DUK__IDX_YEAR], dparts[DUK__IDX_MONTH], dparts[DUK__IDX_DAY]);
-+
-+	/* MakeDate */
-+	d = tmp_day * ((duk_double_t) DUK__MS_DAY) + tmp_time;
-+
-+	DUK_DDD(DUK_DDDPRINT("time=%lf day=%lf --> timeval=%lf",
-+	                     (double) tmp_time, (double) tmp_day, (double) d));
-+
-+	/* Optional UTC conversion. */
-+	if (flags & DUK__FLAG_LOCALTIME) {
-+		/* DUK__GET_LOCAL_TZOFFSET() needs to be called with a time
-+		 * value computed from UTC parts.  At this point we only have
-+		 * 'd' which is a time value computed from local parts, so it
-+		 * is off by the UTC-to-local time offset which we don't know
-+		 * yet.  The current solution for computing the UTC-to-local
-+		 * time offset is to iterate a few times and detect a fixed
-+		 * point or a two-cycle loop (or a sanity iteration limit),
-+		 * see test-bi-date-local-parts.js and test-bi-date-tzoffset-basic-fi.js.
-+		 *
-+		 * E5.1 Section 15.9.1.9:
-+		 * UTC(t) = t - LocalTZA - DaylightSavingTA(t - LocalTZA)
-+		 *
-+		 * For NaN/inf, DUK__GET_LOCAL_TZOFFSET() returns 0.
-+		 */
-+
-+#if 0
-+		/* Old solution: don't iterate, incorrect */
-+		tzoff = DUK__GET_LOCAL_TZOFFSET(d);
-+		DUK_DDD(DUK_DDDPRINT("tzoffset w/o iteration, tzoff=%ld", (long) tzoff));
-+		d -= tzoff * 1000L;
-+		DUK_UNREF(tzoffprev1);
-+		DUK_UNREF(tzoffprev2);
-+#endif
-+
-+		/* Iteration solution */
-+		tzoff = 0;
-+		tzoffprev1 = 999999999L;  /* invalid value which never matches */
-+		for (i = 0; i < DUK__LOCAL_TZOFFSET_MAXITER; i++) {
-+			tzoffprev2 = tzoffprev1;
-+			tzoffprev1 = tzoff;
-+			tzoff = DUK__GET_LOCAL_TZOFFSET(d - tzoff * 1000L);
-+			DUK_DDD(DUK_DDDPRINT("tzoffset iteration, i=%d, tzoff=%ld, tzoffprev1=%ld tzoffprev2=%ld",
-+			                     (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2));
-+			if (tzoff == tzoffprev1) {
-+				DUK_DDD(DUK_DDDPRINT("tzoffset iteration finished, i=%d, tzoff=%ld, tzoffprev1=%ld, tzoffprev2=%ld",
-+				                     (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2));
-+				break;
-+			} else if (tzoff == tzoffprev2) {
-+				/* Two value cycle, see e.g. test-bi-date-tzoffset-basic-fi.js.
-+				 * In these cases, favor a higher tzoffset to get a consistent
-+				 * result which is independent of iteration count.  Not sure if
-+				 * this is a generically correct solution.
-+				 */
-+				DUK_DDD(DUK_DDDPRINT("tzoffset iteration two-value cycle, i=%d, tzoff=%ld, tzoffprev1=%ld, tzoffprev2=%ld",
-+				                     (int) i, (long) tzoff, (long) tzoffprev1, (long) tzoffprev2));
-+				if (tzoffprev1 > tzoff) {
-+					tzoff = tzoffprev1;
-+				}
-+				break;
-+			}
-+		}
-+		DUK_DDD(DUK_DDDPRINT("tzoffset iteration, tzoff=%ld", (long) tzoff));
-+		d -= tzoff * 1000L;
-+	}
-+
-+	/* TimeClip(), which also handles Infinity -> NaN conversion */
-+	d = duk__timeclip(d);
-+
-+	return d;
-+}
-+
-+/*
-+ *  API oriented helpers
-+ */
-+
-+/* Push 'this' binding, check that it is a Date object; then push the
-+ * internal time value.  At the end, stack is: [ ... this timeval ].
-+ * Returns the time value.  Local time adjustment is done if requested.
-+ */
-+DUK_LOCAL duk_double_t duk__push_this_get_timeval_tzoffset(duk_context *ctx, duk_small_uint_t flags, duk_int_t *out_tzoffset) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h;
-+	duk_double_t d;
-+	duk_int_t tzoffset = 0;
-+
-+	duk_push_this(ctx);
-+	h = duk_get_hobject(ctx, -1);  /* XXX: getter with class check, useful in built-ins */
-+	if (h == NULL || DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_DATE) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "expected Date");
-+	}
-+
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-+	d = duk_to_number(ctx, -1);
-+	duk_pop(ctx);
-+
-+	if (DUK_ISNAN(d)) {
-+		if (flags & DUK__FLAG_NAN_TO_ZERO) {
-+			d = 0.0;
-+		}
-+		if (flags & DUK__FLAG_NAN_TO_RANGE_ERROR) {
-+			DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "Invalid Date");
-+		}
-+	}
-+	/* if no NaN handling flag, may still be NaN here, but not Inf */
-+	DUK_ASSERT(!DUK_ISINF(d));
-+
-+	if (flags & DUK__FLAG_LOCALTIME) {
-+		/* Note: DST adjustment is determined using UTC time.
-+		 * If 'd' is NaN, tzoffset will be 0.
-+		 */
-+		tzoffset = DUK__GET_LOCAL_TZOFFSET(d);  /* seconds */
-+		d += tzoffset * 1000L;
-+	}
-+	if (out_tzoffset) {
-+		*out_tzoffset = tzoffset;
-+	}
-+
-+	/* [ ... this ] */
-+	return d;
-+}
-+
-+DUK_LOCAL duk_double_t duk__push_this_get_timeval(duk_context *ctx, duk_small_uint_t flags) {
-+	return duk__push_this_get_timeval_tzoffset(ctx, flags, NULL);
-+}
-+
-+/* Set timeval to 'this' from dparts, push the new time value onto the
-+ * value stack and return 1 (caller can then tailcall us).  Expects
-+ * the value stack to contain 'this' on the stack top.
-+ */
-+DUK_LOCAL duk_ret_t duk__set_this_timeval_from_dparts(duk_context *ctx, duk_double_t *dparts, duk_small_uint_t flags) {
-+	duk_double_t d;
-+
-+	/* [ ... this ] */
-+
-+	d = duk__get_timeval_from_dparts(dparts, flags);
-+	duk_push_number(ctx, d);  /* -> [ ... this timeval_new ] */
-+	duk_dup_top(ctx);         /* -> [ ... this timeval_new timeval_new ] */
-+	duk_put_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE);
-+
-+	/* stack top: new time value, return 1 to allow tailcalls */
-+	return 1;
-+}
-+
-+/* 'out_buf' must be at least DUK_BI_DATE_ISO8601_BUFSIZE long. */
-+DUK_LOCAL void duk__format_parts_iso8601(duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags, duk_uint8_t *out_buf) {
-+	char yearstr[8];   /* "-123456\0" */
-+	char tzstr[8];     /* "+11:22\0" */
-+	char sep = (flags & DUK__FLAG_SEP_T) ? DUK_ASC_UC_T : DUK_ASC_SPACE;
-+
-+	DUK_ASSERT(parts[DUK__IDX_MONTH] >= 1 && parts[DUK__IDX_MONTH] <= 12);
-+	DUK_ASSERT(parts[DUK__IDX_DAY] >= 1 && parts[DUK__IDX_DAY] <= 31);
-+	DUK_ASSERT(parts[DUK__IDX_YEAR] >= -999999 && parts[DUK__IDX_YEAR] <= 999999);
-+
-+	/* Note: %06d for positive value, %07d for negative value to include
-+	 * sign and 6 digits.
-+	 */
-+	DUK_SNPRINTF(yearstr,
-+	             sizeof(yearstr),
-+	             (parts[DUK__IDX_YEAR] >= 0 && parts[DUK__IDX_YEAR] <= 9999) ? "%04ld" :
-+	                    ((parts[DUK__IDX_YEAR] >= 0) ? "+%06ld" : "%07ld"),
-+	             (long) parts[DUK__IDX_YEAR]);
-+	yearstr[sizeof(yearstr) - 1] = (char) 0;
-+
-+	if (flags & DUK__FLAG_LOCALTIME) {
-+		/* tzoffset seconds are dropped; 16 bits suffice for
-+		 * time offset in minutes
-+		 */
-+		if (tzoffset >= 0) {
-+			duk_small_int_t tmp = tzoffset / 60;
-+			DUK_SNPRINTF(tzstr, sizeof(tzstr), "+%02d:%02d", (int) (tmp / 60), (int) (tmp % 60));
-+		} else {
-+			duk_small_int_t tmp = -tzoffset / 60;
-+			DUK_SNPRINTF(tzstr, sizeof(tzstr), "-%02d:%02d", (int) (tmp / 60), (int) (tmp % 60));
-+		}
-+		tzstr[sizeof(tzstr) - 1] = (char) 0;
-+	} else {
-+		tzstr[0] = DUK_ASC_UC_Z;
-+		tzstr[1] = (char) 0;
-+	}
-+
-+	/* Unlike year, the other parts fit into 16 bits so %d format
-+	 * is portable.
-+	 */
-+	if ((flags & DUK__FLAG_TOSTRING_DATE) && (flags & DUK__FLAG_TOSTRING_TIME)) {
-+		DUK_SPRINTF((char *) out_buf, "%s-%02d-%02d%c%02d:%02d:%02d.%03d%s",
-+		            (const char *) yearstr, (int) parts[DUK__IDX_MONTH], (int) parts[DUK__IDX_DAY], (int) sep,
-+		            (int) parts[DUK__IDX_HOUR], (int) parts[DUK__IDX_MINUTE],
-+		            (int) parts[DUK__IDX_SECOND], (int) parts[DUK__IDX_MILLISECOND], (const char *) tzstr);
-+	} else if (flags & DUK__FLAG_TOSTRING_DATE) {
-+		DUK_SPRINTF((char *) out_buf, "%s-%02d-%02d",
-+		            (const char *) yearstr, (int) parts[DUK__IDX_MONTH], (int) parts[DUK__IDX_DAY]);
-+	} else {
-+		DUK_ASSERT(flags & DUK__FLAG_TOSTRING_TIME);
-+		DUK_SPRINTF((char *) out_buf, "%02d:%02d:%02d.%03d%s",
-+		            (int) parts[DUK__IDX_HOUR], (int) parts[DUK__IDX_MINUTE],
-+		            (int) parts[DUK__IDX_SECOND], (int) parts[DUK__IDX_MILLISECOND],
-+		            (const char *) tzstr);
-+	}
-+}
-+
-+/* Helper for string conversion calls: check 'this' binding, get the
-+ * internal time value, and format date and/or time in a few formats.
-+ * Return value allows tail calls.
-+ */
-+DUK_LOCAL duk_ret_t duk__to_string_helper(duk_context *ctx, duk_small_uint_t flags) {
-+	duk_double_t d;
-+	duk_int_t parts[DUK__NUM_PARTS];
-+	duk_int_t tzoffset;  /* seconds, doesn't fit into 16 bits */
-+	duk_bool_t rc;
-+	duk_uint8_t buf[DUK_BI_DATE_ISO8601_BUFSIZE];
-+
-+	DUK_UNREF(rc);  /* unreferenced with some options */
-+
-+	d = duk__push_this_get_timeval_tzoffset(ctx, flags, &tzoffset);
-+	if (DUK_ISNAN(d)) {
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_INVALID_DATE);
-+		return 1;
-+	}
-+	DUK_ASSERT(DUK_ISFINITE(d));
-+
-+	/* formatters always get one-based month/day-of-month */
-+	duk__timeval_to_parts(d, parts, NULL, DUK__FLAG_ONEBASED);
-+	DUK_ASSERT(parts[DUK__IDX_MONTH] >= 1 && parts[DUK__IDX_MONTH] <= 12);
-+	DUK_ASSERT(parts[DUK__IDX_DAY] >= 1 && parts[DUK__IDX_DAY] <= 31);
-+
-+	if (flags & DUK__FLAG_TOSTRING_LOCALE) {
-+		/* try locale specific formatter; if it refuses to format the
-+		 * string, fall back to an ISO 8601 formatted value in local
-+		 * time.
-+		 */
-+#ifdef DUK_USE_DATE_FMT_STRFTIME
-+		rc = duk__format_parts_strftime(ctx, parts, tzoffset, flags);
-+		if (rc != 0) {
-+			return 1;
-+		}
-+#else
-+		/* No locale specific formatter; this is OK, we fall back
-+		 * to ISO 8601.
-+		 */
-+#endif
-+	}
-+
-+	/* Different calling convention than above used because the helper
-+	 * is shared.
-+	 */
-+	duk__format_parts_iso8601(parts, tzoffset, flags, buf);
-+	duk_push_string(ctx, (const char *) buf);
-+	return 1;
-+}
-+
-+/* Helper for component getter calls: check 'this' binding, get the
-+ * internal time value, split it into parts (either as UTC time or
-+ * local time), push a specified component as a return value to the
-+ * value stack and return 1 (caller can then tailcall us).
-+ */
-+DUK_LOCAL duk_ret_t duk__get_part_helper(duk_context *ctx, duk_small_uint_t flags_and_idx) {
-+	duk_double_t d;
-+	duk_int_t parts[DUK__NUM_PARTS];
-+	duk_small_uint_t idx_part = (duk_small_uint_t) (flags_and_idx >> DUK__FLAG_VALUE_SHIFT);  /* unpack args */
-+
-+	DUK_ASSERT_DISABLE(idx_part >= 0);  /* unsigned */
-+	DUK_ASSERT(idx_part < DUK__NUM_PARTS);
-+
-+	d = duk__push_this_get_timeval(ctx, flags_and_idx);
-+	if (DUK_ISNAN(d)) {
-+		duk_push_nan(ctx);
-+		return 1;
-+	}
-+	DUK_ASSERT(DUK_ISFINITE(d));
-+
-+	duk__timeval_to_parts(d, parts, NULL, flags_and_idx);  /* no need to mask idx portion */
-+
-+	/* Setter APIs detect special year numbers (0...99) and apply a +1900
-+	 * only in certain cases.  The legacy getYear() getter applies -1900
-+	 * unconditionally.
-+	 */
-+	duk_push_int(ctx, (flags_and_idx & DUK__FLAG_SUB1900) ? parts[idx_part] - 1900 : parts[idx_part]);
-+	return 1;
-+}
-+
-+/* Helper for component setter calls: check 'this' binding, get the
-+ * internal time value, split it into parts (either as UTC time or
-+ * local time), modify one or more components as specified, recompute
-+ * the time value, set it as the internal value.  Finally, push the
-+ * new time value as a return value to the value stack and return 1
-+ * (caller can then tailcall us).
-+ */
-+DUK_LOCAL duk_ret_t duk__set_part_helper(duk_context *ctx, duk_small_uint_t flags_and_maxnargs) {
-+	duk_double_t d;
-+	duk_int_t parts[DUK__NUM_PARTS];
-+	duk_double_t dparts[DUK__NUM_PARTS];
-+	duk_idx_t nargs;
-+	duk_small_uint_t maxnargs = (duk_small_uint_t) (flags_and_maxnargs >> DUK__FLAG_VALUE_SHIFT);  /* unpack args */
-+	duk_small_uint_t idx_first, idx;
-+	duk_small_uint_t i;
-+
-+	nargs = duk_get_top(ctx);
-+	d = duk__push_this_get_timeval(ctx, flags_and_maxnargs);
-+	DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d));
-+
-+	if (DUK_ISFINITE(d)) {
-+		duk__timeval_to_parts(d, parts, dparts, flags_and_maxnargs);
-+	} else {
-+		/* NaN timevalue: we need to coerce the arguments, but
-+		 * the resulting internal timestamp needs to remain NaN.
-+		 * This works but is not pretty: parts and dparts will
-+		 * be partially uninitialized, but we only write to them.
-+		 */
-+	}
-+
-+	/*
-+	 *  Determining which datetime components to overwrite based on
-+	 *  stack arguments is a bit complicated, but important to factor
-+	 *  out from setters themselves for compactness.
-+	 *
-+	 *  If DUK__FLAG_TIMESETTER, maxnargs indicates setter type:
-+	 *
-+	 *   1 -> millisecond
-+	 *   2 -> second, [millisecond]
-+	 *   3 -> minute, [second], [millisecond]
-+	 *   4 -> hour, [minute], [second], [millisecond]
-+	 *
-+	 *  Else:
-+	 *
-+	 *   1 -> date
-+	 *   2 -> month, [date]
-+	 *   3 -> year, [month], [date]
-+	 *
-+	 *  By comparing nargs and maxnargs (and flags) we know which
-+	 *  components to override.  We rely on part index ordering.
-+	 */
-+
-+	if (flags_and_maxnargs & DUK__FLAG_TIMESETTER) {
-+		DUK_ASSERT(maxnargs >= 1 && maxnargs <= 4);
-+		idx_first = DUK__IDX_MILLISECOND - (maxnargs - 1);
-+	} else {
-+		DUK_ASSERT(maxnargs >= 1 && maxnargs <= 3);
-+		idx_first = DUK__IDX_DAY - (maxnargs - 1);
-+	}
-+	DUK_ASSERT_DISABLE(idx_first >= 0);  /* unsigned */
-+	DUK_ASSERT(idx_first < DUK__NUM_PARTS);
-+
-+	for (i = 0; i < maxnargs; i++) {
-+		if ((duk_idx_t) i >= nargs) {
-+			/* no argument given -> leave components untouched */
-+			break;
-+		}
-+		idx = idx_first + i;
-+		DUK_ASSERT_DISABLE(idx >= 0);  /* unsigned */
-+		DUK_ASSERT(idx < DUK__NUM_PARTS);
-+
-+		if (idx == DUK__IDX_YEAR && (flags_and_maxnargs & DUK__FLAG_YEAR_FIXUP)) {
-+			duk__twodigit_year_fixup(ctx, (duk_idx_t) i);
-+		}
-+
-+		dparts[idx] = duk_to_number(ctx, i);
-+
-+		if (idx == DUK__IDX_DAY) {
-+			/* Day-of-month is one-based in the API, but zero-based
-+			 * internally, so fix here.  Note that month is zero-based
-+			 * both in the API and internally.
-+			 */
-+			/* SCANBUILD: complains about use of uninitialized values.
-+			 * The complaint is correct, but operating in undefined
-+			 * values here is intentional in some cases and the caller
-+			 * ignores the results.
-+			 */
-+			dparts[idx] -= 1.0;
-+		}
-+	}
-+
-+	/* Leaves new timevalue on stack top and returns 1, which is correct
-+	 * for part setters.
-+	 */
-+	if (DUK_ISFINITE(d)) {
-+		return duk__set_this_timeval_from_dparts(ctx, dparts, flags_and_maxnargs);
-+	} else {
-+		/* Internal timevalue is already NaN, so don't touch it. */
-+		duk_push_nan(ctx);
-+		return 1;
-+	}
-+}
-+
-+/* Apply ToNumber() to specified index; if ToInteger(val) in [0,99], add
-+ * 1900 and replace value at idx_val.
-+ */
-+DUK_LOCAL void duk__twodigit_year_fixup(duk_context *ctx, duk_idx_t idx_val) {
-+	duk_double_t d;
-+
-+	/* XXX: idx_val would fit into 16 bits, but using duk_small_uint_t
-+	 * might not generate better code due to casting.
-+	 */
-+
-+	/* E5 Sections 15.9.3.1, B.2.4, B.2.5 */
-+	duk_to_number(ctx, idx_val);
-+	if (duk_is_nan(ctx, idx_val)) {
-+		return;
-+	}
-+	duk_dup(ctx, idx_val);
-+	duk_to_int(ctx, -1);
-+	d = duk_get_number(ctx, -1);  /* get as double to handle huge numbers correctly */
-+	if (d >= 0.0 && d <= 99.0) {
-+		d += 1900.0;
-+		duk_push_number(ctx, d);
-+		duk_replace(ctx, idx_val);
-+	}
-+	duk_pop(ctx);
-+}
-+
-+/* Set datetime parts from stack arguments, defaulting any missing values.
-+ * Day-of-week is not set; it is not required when setting the time value.
-+ */
-+DUK_LOCAL void duk__set_parts_from_args(duk_context *ctx, duk_double_t *dparts, duk_idx_t nargs) {
-+	duk_double_t d;
-+	duk_small_uint_t i;
-+	duk_small_uint_t idx;
-+
-+	/* Causes a ToNumber() coercion, but doesn't break coercion order since
-+	 * year is coerced first anyway.
-+	 */
-+	duk__twodigit_year_fixup(ctx, 0);
-+
-+	/* There are at most 7 args, but we use 8 here so that also
-+	 * DUK__IDX_WEEKDAY gets initialized (to zero) to avoid the potential
-+	 * for any Valgrind gripes later.
-+	 */
-+	for (i = 0; i < 8; i++) {
-+		/* Note: rely on index ordering */
-+		idx = DUK__IDX_YEAR + i;
-+		if ((duk_idx_t) i < nargs) {
-+			d = duk_to_number(ctx, (duk_idx_t) i);
-+			if (idx == DUK__IDX_DAY) {
-+				/* Convert day from one-based to zero-based (internal).  This may
-+				 * cause the day part to be negative, which is OK.
-+				 */
-+				d -= 1.0;
-+			}
-+		} else {
-+			/* All components default to 0 except day-of-month which defaults
-+			 * to 1.  However, because our internal day-of-month is zero-based,
-+			 * it also defaults to zero here.
-+			 */
-+			d = 0.0;
-+		}
-+		dparts[idx] = d;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("parts from args -> %lf %lf %lf %lf %lf %lf %lf %lf",
-+	                     (double) dparts[0], (double) dparts[1],
-+	                     (double) dparts[2], (double) dparts[3],
-+	                     (double) dparts[4], (double) dparts[5],
-+	                     (double) dparts[6], (double) dparts[7]));
-+}
-+
-+/*
-+ *  Helper to format a time value into caller buffer, used by logging.
-+ *  'out_buf' must be at least DUK_BI_DATE_ISO8601_BUFSIZE long.
-+ */
-+
-+DUK_INTERNAL void duk_bi_date_format_timeval(duk_double_t timeval, duk_uint8_t *out_buf) {
-+	duk_int_t parts[DUK__NUM_PARTS];
-+
-+	duk__timeval_to_parts(timeval,
-+	                      parts,
-+	                      NULL,
-+	                      DUK__FLAG_ONEBASED);
-+
-+	duk__format_parts_iso8601(parts,
-+	                          0 /*tzoffset*/,
-+	                          DUK__FLAG_TOSTRING_DATE |
-+	                          DUK__FLAG_TOSTRING_TIME |
-+	                          DUK__FLAG_SEP_T /*flags*/,
-+	                          out_buf);
-+}
-+
-+/*
-+ *  Indirect magic value lookup for Date methods.
-+ *
-+ *  Date methods don't put their control flags into the function magic value
-+ *  because they wouldn't fit into a LIGHTFUNC's magic field.  Instead, the
-+ *  magic value is set to an index pointing to the array of control flags
-+ *  below.
-+ *
-+ *  This must be kept in strict sync with genbuiltins.py!
-+ */
-+
-+static duk_uint16_t duk__date_magics[] = {
-+	/* 0: toString */
-+	DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_TIME + DUK__FLAG_LOCALTIME,
-+
-+	/* 1: toDateString */
-+	DUK__FLAG_TOSTRING_DATE + DUK__FLAG_LOCALTIME,
-+
-+	/* 2: toTimeString */
-+	DUK__FLAG_TOSTRING_TIME + DUK__FLAG_LOCALTIME,
-+
-+	/* 3: toLocaleString */
-+	DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_TIME + DUK__FLAG_TOSTRING_LOCALE + DUK__FLAG_LOCALTIME,
-+
-+	/* 4: toLocaleDateString */
-+	DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_LOCALE + DUK__FLAG_LOCALTIME,
-+
-+	/* 5: toLocaleTimeString */
-+	DUK__FLAG_TOSTRING_TIME + DUK__FLAG_TOSTRING_LOCALE + DUK__FLAG_LOCALTIME,
-+
-+	/* 6: toUTCString */
-+	DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_TIME,
-+
-+	/* 7: toISOString */
-+	DUK__FLAG_TOSTRING_DATE + DUK__FLAG_TOSTRING_TIME + DUK__FLAG_NAN_TO_RANGE_ERROR + DUK__FLAG_SEP_T,
-+
-+	/* 8: getFullYear */
-+	DUK__FLAG_LOCALTIME + (DUK__IDX_YEAR << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 9: getUTCFullYear */
-+	0 + (DUK__IDX_YEAR << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 10: getMonth */
-+	DUK__FLAG_LOCALTIME + (DUK__IDX_MONTH << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 11: getUTCMonth */
-+	0 + (DUK__IDX_MONTH << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 12: getDate */
-+	DUK__FLAG_ONEBASED + DUK__FLAG_LOCALTIME + (DUK__IDX_DAY << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 13: getUTCDate */
-+	DUK__FLAG_ONEBASED + (DUK__IDX_DAY << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 14: getDay */
-+	DUK__FLAG_LOCALTIME + (DUK__IDX_WEEKDAY << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 15: getUTCDay */
-+	0 + (DUK__IDX_WEEKDAY << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 16: getHours */
-+	DUK__FLAG_LOCALTIME + (DUK__IDX_HOUR << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 17: getUTCHours */
-+	0 + (DUK__IDX_HOUR << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 18: getMinutes */
-+	DUK__FLAG_LOCALTIME + (DUK__IDX_MINUTE << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 19: getUTCMinutes */
-+	0 + (DUK__IDX_MINUTE << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 20: getSeconds */
-+	DUK__FLAG_LOCALTIME + (DUK__IDX_SECOND << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 21: getUTCSeconds */
-+	0 + (DUK__IDX_SECOND << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 22: getMilliseconds */
-+	DUK__FLAG_LOCALTIME + (DUK__IDX_MILLISECOND << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 23: getUTCMilliseconds */
-+	0 + (DUK__IDX_MILLISECOND << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 24: setMilliseconds */
-+	DUK__FLAG_TIMESETTER + DUK__FLAG_LOCALTIME + (1 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 25: setUTCMilliseconds */
-+	DUK__FLAG_TIMESETTER + (1 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 26: setSeconds */
-+	DUK__FLAG_TIMESETTER + DUK__FLAG_LOCALTIME + (2 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 27: setUTCSeconds */
-+	DUK__FLAG_TIMESETTER + (2 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 28: setMinutes */
-+	DUK__FLAG_TIMESETTER + DUK__FLAG_LOCALTIME + (3 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 29: setUTCMinutes */
-+	DUK__FLAG_TIMESETTER + (3 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 30: setHours */
-+	DUK__FLAG_TIMESETTER + DUK__FLAG_LOCALTIME + (4 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 31: setUTCHours */
-+	DUK__FLAG_TIMESETTER + (4 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 32: setDate */
-+	DUK__FLAG_LOCALTIME + (1 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 33: setUTCDate */
-+	0 + (1 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 34: setMonth */
-+	DUK__FLAG_LOCALTIME + (2 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 35: setUTCMonth */
-+	0 + (2 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 36: setFullYear */
-+	DUK__FLAG_NAN_TO_ZERO + DUK__FLAG_LOCALTIME + (3 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 37: setUTCFullYear */
-+	DUK__FLAG_NAN_TO_ZERO + (3 << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 38: getYear */
-+	DUK__FLAG_LOCALTIME + DUK__FLAG_SUB1900 + (DUK__IDX_YEAR << DUK__FLAG_VALUE_SHIFT),
-+
-+	/* 39: setYear */
-+	DUK__FLAG_NAN_TO_ZERO + DUK__FLAG_YEAR_FIXUP + (3 << DUK__FLAG_VALUE_SHIFT),
-+};
-+
-+DUK_LOCAL duk_small_uint_t duk__date_get_indirect_magic(duk_context *ctx) {
-+	duk_small_int_t magicidx = (duk_small_uint_t) duk_get_current_magic(ctx);
-+	DUK_ASSERT(magicidx >= 0 && magicidx < (duk_small_int_t) (sizeof(duk__date_magics) / sizeof(duk_uint16_t)));
-+	return (duk_small_uint_t) duk__date_magics[magicidx];
-+}
-+
-+/*
-+ *  Constructor calls
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_constructor(duk_context *ctx) {
-+	duk_idx_t nargs = duk_get_top(ctx);
-+	duk_bool_t is_cons = duk_is_constructor_call(ctx);
-+	duk_double_t dparts[DUK__NUM_PARTS];
-+	duk_double_t d;
-+
-+	DUK_DDD(DUK_DDDPRINT("Date constructor, nargs=%ld, is_cons=%ld", (long) nargs, (long) is_cons));
-+
-+	duk_push_object_helper(ctx,
-+	                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DATE),
-+	                       DUK_BIDX_DATE_PROTOTYPE);
-+
-+	/* Unlike most built-ins, the internal [[PrimitiveValue]] of a Date
-+	 * is mutable.
-+	 */
-+
-+	if (nargs == 0 || !is_cons) {
-+		d = duk__timeclip(DUK__GET_NOW_TIMEVAL(ctx));
-+		duk_push_number(ctx, d);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_W);
-+		if (!is_cons) {
-+			/* called as a normal function: return new Date().toString() */
-+			duk_to_string(ctx, -1);
-+		}
-+		return 1;
-+	} else if (nargs == 1) {
-+		duk_to_primitive(ctx, 0, DUK_HINT_NONE);
-+		if (duk_is_string(ctx, 0)) {
-+			duk__parse_string(ctx, duk_to_string(ctx, 0));
-+			duk_replace(ctx, 0);  /* may be NaN */
-+		}
-+		d = duk__timeclip(duk_to_number(ctx, 0));
-+		duk_push_number(ctx, d);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_W);
-+		return 1;
-+	}
-+
-+	duk__set_parts_from_args(ctx, dparts, nargs);
-+
-+	/* Parts are in local time, convert when setting. */
-+
-+	(void) duk__set_this_timeval_from_dparts(ctx, dparts, DUK__FLAG_LOCALTIME /*flags*/);  /* -> [ ... this timeval ] */
-+	duk_pop(ctx);  /* -> [ ... this ] */
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_constructor_parse(duk_context *ctx) {
-+	return duk__parse_string(ctx, duk_to_string(ctx, 0));
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_constructor_utc(duk_context *ctx) {
-+	duk_idx_t nargs = duk_get_top(ctx);
-+	duk_double_t dparts[DUK__NUM_PARTS];
-+	duk_double_t d;
-+
-+	/* Behavior for nargs < 2 is implementation dependent: currently we'll
-+	 * set a NaN time value (matching V8 behavior) in this case.
-+	 */
-+
-+	if (nargs < 2) {
-+		duk_push_nan(ctx);
-+	} else {
-+		duk__set_parts_from_args(ctx, dparts, nargs);
-+		d = duk__get_timeval_from_dparts(dparts, 0 /*flags*/);
-+		duk_push_number(ctx, d);
-+	}
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_constructor_now(duk_context *ctx) {
-+	duk_double_t d;
-+
-+	d = DUK__GET_NOW_TIMEVAL(ctx);
-+	DUK_ASSERT(duk__timeclip(d) == d);  /* TimeClip() should never be necessary */
-+	duk_push_number(ctx, d);
-+	return 1;
-+}
-+
-+/*
-+ *  String/JSON conversions
-+ *
-+ *  Human readable conversions are now basically ISO 8601 with a space
-+ *  (instead of 'T') as the date/time separator.  This is a good baseline
-+ *  and is platform independent.
-+ *
-+ *  A shared native helper to provide many conversions.  Magic value contains
-+ *  a set of flags.  The helper provides:
-+ *
-+ *    toString()
-+ *    toDateString()
-+ *    toTimeString()
-+ *    toLocaleString()
-+ *    toLocaleDateString()
-+ *    toLocaleTimeString()
-+ *    toUTCString()
-+ *    toISOString()
-+ *
-+ *  Notes:
-+ *
-+ *    - Date.prototype.toGMTString() and Date.prototype.toUTCString() are
-+ *      required to be the same Ecmascript function object (!), so it is
-+ *      omitted from here.
-+ *
-+ *    - Date.prototype.toUTCString(): E5.1 specification does not require a
-+ *      specific format, but result should be human readable.  The
-+ *      specification suggests using ISO 8601 format with a space (instead
-+ *      of 'T') separator if a more human readable format is not available.
-+ *
-+ *    - Date.prototype.toISOString(): unlike other conversion functions,
-+ *      toISOString() requires a RangeError for invalid date values.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_prototype_tostring_shared(duk_context *ctx) {
-+	duk_small_uint_t flags = duk__date_get_indirect_magic(ctx);
-+	return duk__to_string_helper(ctx, flags);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_prototype_value_of(duk_context *ctx) {
-+	/* This native function is also used for Date.prototype.getTime()
-+	 * as their behavior is identical.
-+	 */
-+
-+	duk_double_t d = duk__push_this_get_timeval(ctx, 0 /*flags*/);  /* -> [ this ] */
-+	DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d));
-+	duk_push_number(ctx, d);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_prototype_to_json(duk_context *ctx) {
-+	/* Note: toJSON() is a generic function which works even if 'this'
-+	 * is not a Date.  The sole argument is ignored.
-+	 */
-+
-+	duk_push_this(ctx);
-+	duk_to_object(ctx, -1);
-+
-+	duk_dup_top(ctx);
-+	duk_to_primitive(ctx, -1, DUK_HINT_NUMBER);
-+	if (duk_is_number(ctx, -1)) {
-+		duk_double_t d = duk_get_number(ctx, -1);
-+		if (!DUK_ISFINITE(d)) {
-+			duk_push_null(ctx);
-+			return 1;
-+		}
-+	}
-+	duk_pop(ctx);
-+
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_TO_ISO_STRING);
-+	duk_dup(ctx, -2);  /* -> [ O toIsoString O ] */
-+	duk_call_method(ctx, 0);
-+	return 1;
-+}
-+
-+/*
-+ *  Getters.
-+ *
-+ *  Implementing getters is quite easy.  The internal time value is either
-+ *  NaN, or represents milliseconds (without fractions) from Jan 1, 1970.
-+ *  The internal time value can be converted to integer parts, and each
-+ *  part will be normalized and will fit into a 32-bit signed integer.
-+ *
-+ *  A shared native helper to provide all getters.  Magic value contains
-+ *  a set of flags and also packs the date component index argument.  The
-+ *  helper provides:
-+ *
-+ *    getFullYear()
-+ *    getUTCFullYear()
-+ *    getMonth()
-+ *    getUTCMonth()
-+ *    getDate()
-+ *    getUTCDate()
-+ *    getDay()
-+ *    getUTCDay()
-+ *    getHours()
-+ *    getUTCHours()
-+ *    getMinutes()
-+ *    getUTCMinutes()
-+ *    getSeconds()
-+ *    getUTCSeconds()
-+ *    getMilliseconds()
-+ *    getUTCMilliseconds()
-+ *    getYear()
-+ *
-+ *  Notes:
-+ *
-+ *    - Date.prototype.getDate(): 'date' means day-of-month, and is
-+ *      zero-based in internal calculations but public API expects it to
-+ *      be one-based.
-+ *
-+ *    - Date.prototype.getTime() and Date.prototype.valueOf() have identical
-+ *      behavior.  They have separate function objects, but share the same C
-+ *      function (duk_bi_date_prototype_value_of).
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_shared(duk_context *ctx) {
-+	duk_small_uint_t flags_and_idx = duk__date_get_indirect_magic(ctx);
-+	return duk__get_part_helper(ctx, flags_and_idx);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_prototype_get_timezone_offset(duk_context *ctx) {
-+	/*
-+	 *  Return (t - LocalTime(t)) in minutes:
-+	 *
-+	 *    t - LocalTime(t) = t - (t + LocalTZA + DaylightSavingTA(t))
-+	 *                     = -(LocalTZA + DaylightSavingTA(t))
-+	 *
-+	 *  where DaylightSavingTA() is checked for time 't'.
-+	 *
-+	 *  Note that the sign of the result is opposite to common usage,
-+	 *  e.g. for EE(S)T which normally is +2h or +3h from UTC, this
-+	 *  function returns -120 or -180.
-+	 *
-+	 */
-+
-+	duk_double_t d;
-+	duk_int_t tzoffset;
-+
-+	/* Note: DST adjustment is determined using UTC time. */
-+	d = duk__push_this_get_timeval(ctx, 0 /*flags*/);
-+	DUK_ASSERT(DUK_ISFINITE(d) || DUK_ISNAN(d));
-+	if (DUK_ISNAN(d)) {
-+		duk_push_nan(ctx);
-+	} else {
-+		DUK_ASSERT(DUK_ISFINITE(d));
-+		tzoffset = DUK__GET_LOCAL_TZOFFSET(d);
-+		duk_push_int(ctx, -tzoffset / 60);
-+	}
-+	return 1;
-+}
-+
-+/*
-+ *  Setters.
-+ *
-+ *  Setters are a bit more complicated than getters.  Component setters
-+ *  break down the current time value into its (normalized) component
-+ *  parts, replace one or more components with -unnormalized- new values,
-+ *  and the components are then converted back into a time value.  As an
-+ *  example of using unnormalized values:
-+ *
-+ *    var d = new Date(1234567890);
-+ *
-+ *  is equivalent to:
-+ *
-+ *    var d = new Date(0);
-+ *    d.setUTCMilliseconds(1234567890);
-+ *
-+ *  A shared native helper to provide almost all setters.  Magic value
-+ *  contains a set of flags and also packs the "maxnargs" argument.  The
-+ *  helper provides:
-+ *
-+ *    setMilliseconds()
-+ *    setUTCMilliseconds()
-+ *    setSeconds()
-+ *    setUTCSeconds()
-+ *    setMinutes()
-+ *    setUTCMinutes()
-+ *    setHours()
-+ *    setUTCHours()
-+ *    setDate()
-+ *    setUTCDate()
-+ *    setMonth()
-+ *    setUTCMonth()
-+ *    setFullYear()
-+ *    setUTCFullYear()
-+ *    setYear()
-+ *
-+ *  Notes:
-+ *
-+ *    - Date.prototype.setYear() (Section B addition): special year check
-+ *      is omitted.  NaN / Infinity will just flow through and ultimately
-+ *      result in a NaN internal time value.
-+ *
-+ *    - Date.prototype.setYear() does not have optional arguments for
-+ *      setting month and day-in-month (like setFullYear()), but we indicate
-+ *      'maxnargs' to be 3 to get the year written to the correct component
-+ *      index in duk__set_part_helper().  The function has nargs == 1, so only
-+ *      the year will be set regardless of actual argument count.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_prototype_set_shared(duk_context *ctx) {
-+	duk_small_uint_t flags_and_maxnargs = duk__date_get_indirect_magic(ctx);
-+	return duk__set_part_helper(ctx, flags_and_maxnargs);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_date_prototype_set_time(duk_context *ctx) {
-+	duk_double_t d;
-+
-+	(void) duk__push_this_get_timeval(ctx, 0 /*flags*/); /* -> [ timeval this ] */
-+	d = duk__timeclip(duk_to_number(ctx, 0));
-+	duk_push_number(ctx, d);
-+	duk_dup_top(ctx);
-+	duk_put_prop_stridx(ctx, -3, DUK_STRIDX_INT_VALUE); /* -> [ timeval this timeval ] */
-+
-+	return 1;
-+}
-+#line 1 "duk_bi_duktape.c"
-+/*
-+ *  Duktape built-ins
-+ *
-+ *  Size optimization note: it might seem that vararg multipurpose functions
-+ *  like fin(), enc(), and dec() are not very size optimal, but using a single
-+ *  user-visible Ecmascript function saves a lot of run-time footprint; each
-+ *  Function instance takes >100 bytes.  Using a shared native helper and a
-+ *  'magic' value won't save much if there are multiple Function instances
-+ *  anyway.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* Raw helper to extract internal information / statistics about a value.
-+ * The return values are version specific and must not expose anything
-+ * that would lead to security issues (e.g. exposing compiled function
-+ * 'data' buffer might be an issue).  Currently only counts and sizes and
-+ * such are given so there should not be a security impact.
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_duktape_object_info(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+	duk_heaphdr *h;
-+	duk_int_t i, n;
-+
-+	DUK_UNREF(thr);
-+
-+	/* result array */
-+	duk_push_array(ctx);  /* -> [ val arr ] */
-+
-+	/* type tag (public) */
-+	duk_push_int(ctx, duk_get_type(ctx, 0));
-+
-+	/* address */
-+	tv = duk_get_tval(ctx, 0);
-+	DUK_ASSERT(tv != NULL);  /* because arg count is 1 */
-+	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		h = DUK_TVAL_GET_HEAPHDR(tv);
-+		duk_push_pointer(ctx, (void *) h);
-+	} else {
-+		/* internal type tag */
-+		duk_push_int(ctx, (duk_int_t) DUK_TVAL_GET_TAG(tv));
-+		goto done;
-+	}
-+	DUK_ASSERT(h != NULL);
-+
-+	/* refcount */
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk_push_size_t(ctx, DUK_HEAPHDR_GET_REFCOUNT(h));
-+#else
-+	duk_push_undefined(ctx);
-+#endif
-+
-+	/* heaphdr size and additional allocation size, followed by
-+	 * type specific stuff (with varying value count)
-+	 */
-+	switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) {
-+	case DUK_HTYPE_STRING: {
-+		duk_hstring *h_str = (duk_hstring *) h;
-+		duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hstring) + DUK_HSTRING_GET_BYTELEN(h_str) + 1));
-+		break;
-+	}
-+	case DUK_HTYPE_OBJECT: {
-+		duk_hobject *h_obj = (duk_hobject *) h;
-+		duk_small_uint_t hdr_size;
-+		if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) {
-+			hdr_size = (duk_small_uint_t) sizeof(duk_hcompiledfunction);
-+		} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h_obj)) {
-+			hdr_size = (duk_small_uint_t) sizeof(duk_hnativefunction);
-+		} else if (DUK_HOBJECT_IS_THREAD(h_obj)) {
-+			hdr_size = (duk_small_uint_t) sizeof(duk_hthread);
-+		} else {
-+			hdr_size = (duk_small_uint_t) sizeof(duk_hobject);
-+		}
-+		duk_push_uint(ctx, (duk_uint_t) hdr_size);
-+		duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_E_ALLOC_SIZE(h_obj));
-+		duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ESIZE(h_obj));
-+		/* Note: e_next indicates the number of gc-reachable entries
-+		 * in the entry part, and also indicates the index where the
-+		 * next new property would be inserted.  It does *not* indicate
-+		 * the number of non-NULL keys present in the object.  That
-+		 * value could be counted separately but requires a pass through
-+		 * the key list.
-+		 */
-+		duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ENEXT(h_obj));
-+		duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_ASIZE(h_obj));
-+		duk_push_uint(ctx, (duk_uint_t) DUK_HOBJECT_GET_HSIZE(h_obj));
-+		if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h_obj)) {
-+			duk_hbuffer *h_data = (duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, (duk_hcompiledfunction *) h_obj);
-+			if (h_data) {
-+				duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_data));
-+			} else {
-+				duk_push_uint(ctx, 0);
-+			}
-+		}
-+		break;
-+	}
-+	case DUK_HTYPE_BUFFER: {
-+		duk_hbuffer *h_buf = (duk_hbuffer *) h;
-+		if (DUK_HBUFFER_HAS_DYNAMIC(h_buf)) {
-+			/* XXX: when alloc_size == 0, dynamic buf ptr may now be NULL, in which case
-+			 * the second allocation does not exist.
-+			 */
-+			duk_hbuffer_dynamic *h_dyn = (duk_hbuffer_dynamic *) h;
-+			duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_dynamic)));
-+			duk_push_uint(ctx, (duk_uint_t) (DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(h_dyn)));
-+		} else {
-+			duk_push_uint(ctx, (duk_uint_t) (sizeof(duk_hbuffer_fixed) + DUK_HBUFFER_GET_SIZE(h_buf) + 1));
-+		}
-+		break;
-+
-+	}
-+	}
-+
-+ done:
-+	/* set values into ret array */
-+	/* XXX: primitive to make array from valstack slice */
-+	n = duk_get_top(ctx);
-+	for (i = 2; i < n; i++) {
-+		duk_dup(ctx, i);
-+		duk_put_prop_index(ctx, 1, i - 2);
-+	}
-+	duk_dup(ctx, 1);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_duktape_object_act(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_activation *act;
-+	duk_uint_fast32_t pc;
-+	duk_uint_fast32_t line;
-+	duk_int_t level;
-+
-+	/* -1             = top callstack entry, callstack[callstack_top - 1]
-+	 * -callstack_top = bottom callstack entry, callstack[0]
-+	 */
-+	level = duk_to_int(ctx, 0);
-+	if (level >= 0 || -level > (duk_int_t) thr->callstack_top) {
-+		return 0;
-+	}
-+	DUK_ASSERT(level >= -((duk_int_t) thr->callstack_top) && level <= -1);
-+	act = thr->callstack + thr->callstack_top + level;
-+
-+	duk_push_object(ctx);
-+
-+	duk_push_tval(ctx, &act->tv_func);
-+
-+	pc = (duk_uint_fast32_t) act->pc;
-+	if (pc > 0) {
-+		/* Relevant PC is just before current one because PC is
-+		 * post-incremented.  This should match what error augment
-+		 * code does.
-+		 */
-+		pc--;
-+	}
-+	duk_push_uint(ctx, (duk_uint_t) pc);
-+
-+#if defined(DUK_USE_PC2LINE)
-+	line = duk_hobject_pc2line_query(ctx, -2, pc);
-+#else
-+	line = 0;
-+#endif
-+	duk_push_uint(ctx, (duk_uint_t) line);
-+
-+	/* Providing access to e.g. act->lex_env would be dangerous: these
-+	 * internal structures must never be accessible to the application.
-+	 * Duktape relies on them having consistent data, and this consistency
-+	 * is only asserted for, not checked for.
-+	 */
-+
-+	/* [ level obj func pc line ] */
-+
-+	/* XXX: version specific array format instead? */
-+	duk_xdef_prop_stridx_wec(ctx, -4, DUK_STRIDX_LINE_NUMBER);
-+	duk_xdef_prop_stridx_wec(ctx, -3, DUK_STRIDX_PC);
-+	duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_LC_FUNCTION);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_duktape_object_gc(duk_context *ctx) {
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_small_uint_t flags;
-+	duk_bool_t rc;
-+
-+	flags = (duk_small_uint_t) duk_get_uint(ctx, 0);
-+	rc = duk_heap_mark_and_sweep(thr->heap, flags);
-+
-+	/* XXX: Not sure what the best return value would be in the API.
-+	 * Return a boolean for now.  Note that rc == 0 is success (true).
-+	 */
-+	duk_push_boolean(ctx, !rc);
-+	return 1;
-+#else
-+	DUK_UNREF(ctx);
-+	return 0;
-+#endif
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_duktape_object_fin(duk_context *ctx) {
-+	(void) duk_require_hobject(ctx, 0);
-+	if (duk_get_top(ctx) >= 2) {
-+		/* Set: currently a finalizer is disabled by setting it to
-+		 * undefined; this does not remove the property at the moment.
-+		 * The value could be type checked to be either a function
-+		 * or something else; if something else, the property could
-+		 * be deleted.
-+		 */
-+		duk_set_top(ctx, 2);
-+		(void) duk_put_prop_stridx(ctx, 0, DUK_STRIDX_INT_FINALIZER);
-+		return 0;
-+	} else {
-+		/* Get. */
-+		DUK_ASSERT(duk_get_top(ctx) == 1);
-+		duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_FINALIZER);
-+		return 1;
-+	}
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_duktape_object_enc(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_str;
-+
-+	/* Vararg function: must be careful to check/require arguments.
-+	 * The JSON helpers accept invalid indices and treat them like
-+	 * non-existent optional parameters.
-+	 */
-+
-+	h_str = duk_require_hstring(ctx, 0);
-+	duk_require_valid_index(ctx, 1);
-+
-+	if (h_str == DUK_HTHREAD_STRING_HEX(thr)) {
-+		duk_set_top(ctx, 2);
-+		duk_hex_encode(ctx, 1);
-+		DUK_ASSERT_TOP(ctx, 2);
-+	} else if (h_str == DUK_HTHREAD_STRING_BASE64(thr)) {
-+		duk_set_top(ctx, 2);
-+		duk_base64_encode(ctx, 1);
-+		DUK_ASSERT_TOP(ctx, 2);
-+#ifdef DUK_USE_JX
-+	} else if (h_str == DUK_HTHREAD_STRING_JX(thr)) {
-+		duk_bi_json_stringify_helper(ctx,
-+		                             1 /*idx_value*/,
-+		                             2 /*idx_replacer*/,
-+		                             3 /*idx_space*/,
-+		                             DUK_JSON_FLAG_EXT_CUSTOM |
-+		                             DUK_JSON_FLAG_ASCII_ONLY |
-+		                             DUK_JSON_FLAG_AVOID_KEY_QUOTES /*flags*/);
-+#endif
-+#ifdef DUK_USE_JC
-+	} else if (h_str == DUK_HTHREAD_STRING_JC(thr)) {
-+		duk_bi_json_stringify_helper(ctx,
-+		                             1 /*idx_value*/,
-+		                             2 /*idx_replacer*/,
-+		                             3 /*idx_space*/,
-+		                             DUK_JSON_FLAG_EXT_COMPATIBLE |
-+		                             DUK_JSON_FLAG_ASCII_ONLY /*flags*/);
-+#endif
-+	} else {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_duktape_object_dec(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_str;
-+
-+	/* Vararg function: must be careful to check/require arguments.
-+	 * The JSON helpers accept invalid indices and treat them like
-+	 * non-existent optional parameters.
-+	 */
-+
-+	h_str = duk_require_hstring(ctx, 0);
-+	duk_require_valid_index(ctx, 1);
-+
-+	if (h_str == DUK_HTHREAD_STRING_HEX(thr)) {
-+		duk_set_top(ctx, 2);
-+		duk_hex_decode(ctx, 1);
-+		DUK_ASSERT_TOP(ctx, 2);
-+	} else if (h_str == DUK_HTHREAD_STRING_BASE64(thr)) {
-+		duk_set_top(ctx, 2);
-+		duk_base64_decode(ctx, 1);
-+		DUK_ASSERT_TOP(ctx, 2);
-+#ifdef DUK_USE_JX
-+	} else if (h_str == DUK_HTHREAD_STRING_JX(thr)) {
-+		duk_bi_json_parse_helper(ctx,
-+		                         1 /*idx_value*/,
-+		                         2 /*idx_replacer*/,
-+		                         DUK_JSON_FLAG_EXT_CUSTOM /*flags*/);
-+#endif
-+#ifdef DUK_USE_JC
-+	} else if (h_str == DUK_HTHREAD_STRING_JC(thr)) {
-+		duk_bi_json_parse_helper(ctx,
-+		                         1 /*idx_value*/,
-+		                         2 /*idx_replacer*/,
-+		                         DUK_JSON_FLAG_EXT_COMPATIBLE /*flags*/);
-+#endif
-+	} else {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+	return 1;
-+}
-+
-+/*
-+ *  Compact an object
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_duktape_object_compact(duk_context *ctx) {
-+	DUK_ASSERT_TOP(ctx, 1);
-+	duk_compact(ctx, 0);
-+	return 1;  /* return the argument object */
-+}
-+#line 1 "duk_bi_error.c"
-+/*
-+ *  Error built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_constructor_shared(duk_context *ctx) {
-+	/* Behavior for constructor and non-constructor call is
-+	 * the same except for augmenting the created error.  When
-+	 * called as a constructor, the caller (duk_new()) will handle
-+	 * augmentation; when called as normal function, we need to do
-+	 * it here.
-+	 */
-+
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_small_int_t bidx_prototype = duk_get_current_magic(ctx);
-+
-+	/* same for both error and each subclass like TypeError */
-+	duk_uint_t flags_and_class = DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                             DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ERROR);
-+
-+	DUK_UNREF(thr);
-+
-+	duk_push_object_helper(ctx, flags_and_class, bidx_prototype);
-+
-+	/* If message is undefined, the own property 'message' is not set at
-+	 * all to save property space.  An empty message is inherited anyway.
-+	 */
-+	if (!duk_is_undefined(ctx, 0)) {
-+		duk_to_string(ctx, 0);
-+		duk_dup(ctx, 0);  /* [ message error message ] */
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE, DUK_PROPDESC_FLAGS_WC);
-+	}
-+
-+	/* Augment the error if called as a normal function.  __FILE__ and __LINE__
-+	 * are not desirable in this case.
-+	 */
-+
-+#ifdef DUK_USE_AUGMENT_ERROR_CREATE
-+	if (!duk_is_constructor_call(ctx)) {
-+		duk_err_augment_error_create(thr, thr, NULL, 0, 1 /*noblame_fileline*/);
-+	}
-+#endif
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_prototype_to_string(duk_context *ctx) {
-+	/* XXX: optimize with more direct internal access */
-+
-+	duk_push_this(ctx);
-+	(void) duk_require_hobject_or_lfunc_coerce(ctx, -1);
-+
-+	/* [ ... this ] */
-+
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);
-+	if (duk_is_undefined(ctx, -1)) {
-+		duk_pop(ctx);
-+		duk_push_string(ctx, "Error");
-+	} else {
-+		duk_to_string(ctx, -1);
-+	}
-+
-+	/* [ ... this name ] */
-+
-+	/* XXX: Are steps 6 and 7 in E5 Section 15.11.4.4 duplicated by
-+	 * accident or are they actually needed?  The first ToString()
-+	 * could conceivably return 'undefined'.
-+	 */
-+	duk_get_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE);
-+	if (duk_is_undefined(ctx, -1)) {
-+		duk_pop(ctx);
-+		duk_push_string(ctx, "");
-+	} else {
-+		duk_to_string(ctx, -1);
-+	}
-+
-+	/* [ ... this name message ] */
-+
-+	if (duk_get_length(ctx, -2) == 0) {
-+		/* name is empty -> return message */
-+		return 1;
-+	}
-+	if (duk_get_length(ctx, -1) == 0) {
-+		/* message is empty -> return name */
-+		duk_pop(ctx);
-+		return 1;
-+	}
-+	duk_push_string(ctx, ": ");
-+	duk_insert(ctx, -2);  /* ... name ': ' message */
-+	duk_concat(ctx, 3);
-+
-+	return 1;
-+}
-+
-+#ifdef DUK_USE_TRACEBACKS
-+
-+/*
-+ *  Traceback handling
-+ *
-+ *  The unified helper decodes the traceback and produces various requested
-+ *  outputs.  It should be optimized for size, and may leave garbage on stack,
-+ *  only the topmost return value matters.  For instance, traceback separator
-+ *  and decoded strings are pushed even when looking for filename only.
-+ *
-+ *  NOTE: although _Tracedata is an internal property, user code can currently
-+ *  write to the array (or replace it with something other than an array).
-+ *  The code below must tolerate arbitrary _Tracedata.  It can throw errors
-+ *  etc, but cannot cause a segfault or memory unsafe behavior.
-+ */
-+
-+/* constants arbitrary, chosen for small loads */
-+#define DUK__OUTPUT_TYPE_TRACEBACK   (-1)
-+#define DUK__OUTPUT_TYPE_FILENAME    0
-+#define DUK__OUTPUT_TYPE_LINENUMBER  1
-+
-+DUK_LOCAL duk_ret_t duk__traceback_getter_helper(duk_context *ctx, duk_small_int_t output_type) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t idx_td;
-+	duk_small_int_t i;  /* traceback depth fits into 16 bits */
-+	duk_small_int_t t;  /* stack type fits into 16 bits */
-+	const char *str_tailcalled = " tailcalled";
-+	const char *str_strict = " strict";
-+	const char *str_construct = " construct";
-+	const char *str_prevyield = " preventsyield";
-+	const char *str_directeval = " directeval";
-+	const char *str_empty = "";
-+
-+	DUK_ASSERT_TOP(ctx, 0);  /* fixed arg count */
-+
-+	duk_push_this(ctx);
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TRACEDATA);
-+	idx_td = duk_get_top_index(ctx);
-+
-+	duk_push_hstring_stridx(ctx, DUK_STRIDX_NEWLINE_TAB);
-+	duk_push_this(ctx);
-+
-+	/* [ ... this tracedata sep this ] */
-+
-+	/* XXX: skip null filename? */
-+
-+	if (duk_check_type(ctx, idx_td, DUK_TYPE_OBJECT)) {
-+		/* Current tracedata contains 2 entries per callstack entry. */
-+		for (i = 0; ; i += 2) {
-+			duk_int_t pc;
-+			duk_int_t line;
-+			duk_int_t flags;
-+			duk_double_t d;
-+			const char *funcname;
-+			const char *filename;
-+			duk_hobject *h_func;
-+			duk_hstring *h_name;
-+
-+			duk_require_stack(ctx, 5);
-+			duk_get_prop_index(ctx, idx_td, i);
-+			duk_get_prop_index(ctx, idx_td, i + 1);
-+			d = duk_to_number(ctx, -1);
-+			pc = (duk_int_t) DUK_FMOD(d, DUK_DOUBLE_2TO32);
-+			flags = (duk_int_t) DUK_FLOOR(d / DUK_DOUBLE_2TO32);
-+			t = (duk_small_int_t) duk_get_type(ctx, -2);
-+
-+			if (t == DUK_TYPE_OBJECT || t == DUK_TYPE_LIGHTFUNC) {
-+				/*
-+				 *  Ecmascript/native function call or lightfunc call
-+				 */
-+
-+				/* [ ... v1(func) v2(pc+flags) ] */
-+
-+				h_func = duk_get_hobject(ctx, -2);  /* NULL for lightfunc */
-+
-+				duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);
-+				duk_get_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME);
-+
-+#if defined(DUK_USE_PC2LINE)
-+				line = duk_hobject_pc2line_query(ctx, -4, (duk_uint_fast32_t) pc);
-+#else
-+				line = 0;
-+#endif
-+
-+				/* [ ... v1 v2 name filename ] */
-+
-+				if (output_type == DUK__OUTPUT_TYPE_FILENAME) {
-+					return 1;
-+				} else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) {
-+					duk_push_int(ctx, line);
-+					return 1;
-+				}
-+
-+				h_name = duk_get_hstring(ctx, -2);  /* may be NULL */
-+				funcname = (h_name == NULL || h_name == DUK_HTHREAD_STRING_EMPTY_STRING(thr)) ?
-+				           "anon" : (const char *) DUK_HSTRING_GET_DATA(h_name);
-+				filename = duk_get_string(ctx, -1);
-+				filename = filename ? filename : "";
-+				DUK_ASSERT(funcname != NULL);
-+				DUK_ASSERT(filename != NULL);
-+
-+				if (h_func == NULL) {
-+					duk_push_sprintf(ctx, "%s light%s%s%s%s%s",
-+					                 (const char *) funcname,
-+					                 (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcalled : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
-+				} else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(h_func)) {
-+					duk_push_sprintf(ctx, "%s %s native%s%s%s%s%s",
-+					                 (const char *) funcname,
-+					                 (const char *) filename,
-+					                 (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcalled : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
-+				} else {
-+					duk_push_sprintf(ctx, "%s %s:%ld%s%s%s%s%s",
-+					                 (const char *) funcname,
-+					                 (const char *) filename,
-+					                 (long) line,
-+					                 (const char *) ((flags & DUK_ACT_FLAG_STRICT) ? str_strict : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_TAILCALLED) ? str_tailcalled : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_CONSTRUCT) ? str_construct : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_DIRECT_EVAL) ? str_directeval : str_empty),
-+					                 (const char *) ((flags & DUK_ACT_FLAG_PREVENT_YIELD) ? str_prevyield : str_empty));
-+				}
-+				duk_replace(ctx, -5);   /* [ ... v1 v2 name filename str ] -> [ ... str v2 name filename ] */
-+				duk_pop_n(ctx, 3);      /* -> [ ... str ] */
-+			} else if (t == DUK_TYPE_STRING) {
-+				/*
-+				 *  __FILE__ / __LINE__ entry, here 'pc' is line number directly.
-+				 *  Sometimes __FILE__ / __LINE__ is reported as the source for
-+				 *  the error (fileName, lineNumber), sometimes not.
-+				 */
-+
-+				/* [ ... v1(filename) v2(line+flags) ] */
-+
-+				if (!(flags & DUK_TB_FLAG_NOBLAME_FILELINE)) {
-+					if (output_type == DUK__OUTPUT_TYPE_FILENAME) {
-+						duk_pop(ctx);
-+						return 1;
-+					} else if (output_type == DUK__OUTPUT_TYPE_LINENUMBER) {
-+						duk_push_int(ctx, pc);
-+						return 1;
-+					}
-+				}
-+
-+				duk_push_sprintf(ctx, "%s:%ld",
-+				                 (const char *) duk_get_string(ctx, -2), (long) pc);
-+				duk_replace(ctx, -3);  /* [ ... v1 v2 str ] -> [ ... str v2 ] */
-+				duk_pop(ctx);          /* -> [ ... str ] */
-+			} else {
-+				/* unknown, ignore */
-+				duk_pop_2(ctx);
-+				break;
-+			}
-+		}
-+
-+		if (i >= DUK_USE_TRACEBACK_DEPTH * 2) {
-+			/* Possibly truncated; there is no explicit truncation
-+			 * marker so this is the best we can do.
-+			 */
-+
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_BRACKETED_ELLIPSIS);
-+		}
-+	}
-+
-+	/* [ ... this tracedata sep this str1 ... strN ] */
-+
-+	if (output_type != DUK__OUTPUT_TYPE_TRACEBACK) {
-+		return 0;
-+	} else {
-+		/* The 'this' after 'sep' will get ToString() coerced by
-+		 * duk_join() automatically.  We don't want to do that
-+		 * coercion when providing .fileName or .lineNumber (GH-254).
-+		 */
-+		duk_join(ctx, duk_get_top(ctx) - (idx_td + 2) /*count, not including sep*/);
-+		return 1;
-+	}
-+}
-+
-+/* XXX: output type could be encoded into native function 'magic' value to
-+ * save space.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_getter(duk_context *ctx) {
-+	return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_TRACEBACK);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_getter(duk_context *ctx) {
-+	return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_FILENAME);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx) {
-+	return duk__traceback_getter_helper(ctx, DUK__OUTPUT_TYPE_LINENUMBER);
-+}
-+
-+#undef DUK__OUTPUT_TYPE_TRACEBACK
-+#undef DUK__OUTPUT_TYPE_FILENAME
-+#undef DUK__OUTPUT_TYPE_LINENUMBER
-+
-+#else  /* DUK_USE_TRACEBACKS */
-+
-+/*
-+ *  Traceback handling when tracebacks disabled.
-+ *
-+ *  The fileName / lineNumber stubs are now necessary because built-in
-+ *  data will include the accessor properties in Error.prototype.  If those
-+ *  are removed for builds without tracebacks, these can also be removed.
-+ *  'stack' should still be present and produce a ToString() equivalent:
-+ *  this is useful for user code which prints a stacktrace and expects to
-+ *  see something useful.  A normal stacktrace also begins with a ToString()
-+ *  of the error so this makes sense.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_prototype_stack_getter(duk_context *ctx) {
-+	/* XXX: remove this native function and map 'stack' accessor
-+	 * to the toString() implementation directly.
-+	 */
-+	return duk_bi_error_prototype_to_string(ctx);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_prototype_filename_getter(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return 0;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_prototype_linenumber_getter(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return 0;
-+}
-+
-+#endif  /* DUK_USE_TRACEBACKS */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_error_prototype_nop_setter(duk_context *ctx) {
-+	/* Attempt to write 'stack', 'fileName', 'lineNumber' is a silent no-op.
-+	 * User can use Object.defineProperty() to override this behavior.
-+	 */
-+	DUK_ASSERT_TOP(ctx, 1);  /* fixed arg count */
-+	DUK_UNREF(ctx);
-+	return 0;
-+}
-+#line 1 "duk_bi_function.c"
-+/*
-+ *  Function built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_function_constructor(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_sourcecode;
-+	duk_idx_t nargs;
-+	duk_idx_t i;
-+	duk_small_uint_t comp_flags;
-+	duk_hcompiledfunction *func;
-+	duk_hobject *outer_lex_env;
-+	duk_hobject *outer_var_env;
-+
-+	/* normal and constructor calls have identical semantics */
-+
-+	nargs = duk_get_top(ctx);
-+	for (i = 0; i < nargs; i++) {
-+		duk_to_string(ctx, i);
-+	}
-+
-+	if (nargs == 0) {
-+		duk_push_string(ctx, "");
-+		duk_push_string(ctx, "");
-+	} else if (nargs == 1) {
-+		/* XXX: cover this with the generic >1 case? */
-+		duk_push_string(ctx, "");
-+	} else {
-+		duk_insert(ctx, 0);   /* [ arg1 ... argN-1 body] -> [body arg1 ... argN-1] */
-+		duk_push_string(ctx, ",");
-+		duk_insert(ctx, 1);
-+		duk_join(ctx, nargs - 1);
-+	}
-+
-+	/* [ body formals ], formals is comma separated list that needs to be parsed */
-+
-+	DUK_ASSERT_TOP(ctx, 2);
-+
-+	/* XXX: this placeholder is not always correct, but use for now.
-+	 * It will fail in corner cases; see test-dev-func-cons-args.js.
-+	 */
-+	duk_push_string(ctx, "function(");
-+	duk_dup(ctx, 1);
-+	duk_push_string(ctx, "){");
-+	duk_dup(ctx, 0);
-+	duk_push_string(ctx, "}");
-+	duk_concat(ctx, 5);
-+
-+	/* [ body formals source ] */
-+
-+	DUK_ASSERT_TOP(ctx, 3);
-+
-+	/* strictness is not inherited, intentional */
-+	comp_flags = DUK_JS_COMPILE_FLAG_FUNCEXPR;
-+
-+	duk_push_hstring_stridx(ctx, DUK_STRIDX_COMPILE);  /* XXX: copy from caller? */  /* XXX: ignored now */
-+	h_sourcecode = duk_require_hstring(ctx, -2);
-+	duk_js_compile(thr,
-+	               (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_sourcecode),
-+	               (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sourcecode),
-+	               comp_flags);
-+	func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) func));
-+
-+	/* [ body formals source template ] */
-+
-+	/* only outer_lex_env matters, as functions always get a new
-+	 * variable declaration environment.
-+	 */
-+
-+	outer_lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+	outer_var_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+
-+	duk_js_push_closure(thr, func, outer_var_env, outer_lex_env);
-+
-+	/* [ body formals source template closure ] */
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_function_prototype(duk_context *ctx) {
-+	/* ignore arguments, return undefined (E5 Section 15.3.4) */
-+	DUK_UNREF(ctx);
-+	return 0;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_function_prototype_to_string(duk_context *ctx) {
-+	duk_tval *tv;
-+
-+	/*
-+	 *  E5 Section 15.3.4.2 places few requirements on the output of
-+	 *  this function:
-+	 *
-+	 *    - The result is an implementation dependent representation
-+	 *      of the function; in particular
-+	 *
-+	 *    - The result must follow the syntax of a FunctionDeclaration.
-+	 *      In particular, the function must have a name (even in the
-+	 *      case of an anonymous function or a function with an empty
-+	 *      name).
-+	 *
-+	 *    - Note in particular that the output does NOT need to compile
-+	 *      into anything useful.
-+	 */
-+
-+
-+	/* XXX: faster internal way to get this */
-+	duk_push_this(ctx);
-+	tv = duk_get_tval(ctx, -1);
-+	DUK_ASSERT(tv != NULL);
-+
-+	if (DUK_TVAL_IS_OBJECT(tv)) {
-+		duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv);
-+		const char *func_name = DUK_STR_ANON;
-+
-+		/* XXX: rework, it would be nice to avoid C formatting functions to
-+		 * ensure there are no Unicode issues.
-+		 */
-+
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);
-+		if (!duk_is_undefined(ctx, -1)) {
-+			func_name = duk_to_string(ctx, -1);
-+			DUK_ASSERT(func_name != NULL);
-+
-+			if (func_name[0] == (char) 0) {
-+				func_name = DUK_STR_ANON;
-+			}
-+		}
-+
-+		if (DUK_HOBJECT_HAS_COMPILEDFUNCTION(obj)) {
-+			/* XXX: actual source, if available */
-+			duk_push_sprintf(ctx, "function %s() {/* ecmascript */}", (const char *) func_name);
-+		} else if (DUK_HOBJECT_HAS_NATIVEFUNCTION(obj)) {
-+			duk_push_sprintf(ctx, "function %s() {/* native */}", (const char *) func_name);
-+		} else if (DUK_HOBJECT_HAS_BOUND(obj)) {
-+			duk_push_sprintf(ctx, "function %s() {/* bound */}", (const char *) func_name);
-+		} else {
-+			goto type_error;
-+		}
-+	} else if (DUK_TVAL_IS_LIGHTFUNC(tv)) {
-+		duk_push_lightfunc_tostring(ctx, tv);
-+	} else {
-+		goto type_error;
-+	}
-+
-+	return 1;
-+
-+ type_error:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_function_prototype_apply(duk_context *ctx) {
-+	duk_idx_t len;
-+	duk_idx_t i;
-+
-+	DUK_ASSERT_TOP(ctx, 2);  /* not a vararg function */
-+
-+	duk_push_this(ctx);
-+	if (!duk_is_callable(ctx, -1)) {
-+		DUK_DDD(DUK_DDDPRINT("func is not callable"));
-+		goto type_error;
-+	}
-+	duk_insert(ctx, 0);
-+	DUK_ASSERT_TOP(ctx, 3);
-+
-+	DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argArray=%!iT",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 1),
-+	                     (duk_tval *) duk_get_tval(ctx, 2)));
-+
-+	/* [ func thisArg argArray ] */
-+
-+	if (duk_is_null_or_undefined(ctx, 2)) {
-+		DUK_DDD(DUK_DDDPRINT("argArray is null/undefined, no args"));
-+		len = 0;
-+	} else if (!duk_is_object(ctx, 2)) {
-+		goto type_error;
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("argArray is an object"));
-+
-+		/* XXX: make this an internal helper */
-+		duk_get_prop_stridx(ctx, 2, DUK_STRIDX_LENGTH);
-+		len = (duk_idx_t) duk_to_uint32(ctx, -1);  /* ToUint32() coercion required */
-+		duk_pop(ctx);
-+
-+		duk_require_stack(ctx, len);
-+
-+		DUK_DDD(DUK_DDDPRINT("argArray length is %ld", (long) len));
-+		for (i = 0; i < len; i++) {
-+			duk_get_prop_index(ctx, 2, i);
-+		}
-+	}
-+	duk_remove(ctx, 2);
-+	DUK_ASSERT_TOP(ctx, 2 + len);
-+
-+	/* [ func thisArg arg1 ... argN ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("apply, func=%!iT, thisArg=%!iT, len=%ld",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 1),
-+	                     (long) len));
-+	duk_call_method(ctx, len);
-+	return 1;
-+
-+ type_error:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_function_prototype_call(duk_context *ctx) {
-+	duk_idx_t nargs;
-+
-+	/* Step 1 is not necessary because duk_call_method() will take
-+	 * care of it.
-+	 */
-+
-+	/* vararg function, thisArg needs special handling */
-+	nargs = duk_get_top(ctx);  /* = 1 + arg count */
-+	if (nargs == 0) {
-+		duk_push_undefined(ctx);
-+		nargs++;
-+	}
-+	DUK_ASSERT(nargs >= 1);
-+
-+	/* [ thisArg arg1 ... argN ] */
-+
-+	duk_push_this(ctx);  /* 'func' in the algorithm */
-+	duk_insert(ctx, 0);
-+
-+	/* [ func thisArg arg1 ... argN ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("func=%!iT, thisArg=%!iT, argcount=%ld, top=%ld",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 1),
-+	                     (long) (nargs - 1),
-+	                     (long) duk_get_top(ctx)));
-+	duk_call_method(ctx, nargs - 1);
-+	return 1;
-+}
-+
-+/* XXX: the implementation now assumes "chained" bound functions,
-+ * whereas "collapsed" bound functions (where there is ever only
-+ * one bound function which directly points to a non-bound, final
-+ * function) would require a "collapsing" implementation which
-+ * merges argument lists etc here.
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_function_prototype_bind(duk_context *ctx) {
-+	duk_hobject *h_bound;
-+	duk_hobject *h_target;
-+	duk_idx_t nargs;
-+	duk_idx_t i;
-+
-+	/* vararg function, careful arg handling (e.g. thisArg may not be present) */
-+	nargs = duk_get_top(ctx);  /* = 1 + arg count */
-+	if (nargs == 0) {
-+		duk_push_undefined(ctx);
-+		nargs++;
-+	}
-+	DUK_ASSERT(nargs >= 1);
-+
-+	duk_push_this(ctx);
-+	if (!duk_is_callable(ctx, -1)) {
-+		DUK_DDD(DUK_DDDPRINT("func is not callable"));
-+		goto type_error;
-+	}
-+
-+	/* [ thisArg arg1 ... argN func ]  (thisArg+args == nargs total) */
-+	DUK_ASSERT_TOP(ctx, nargs + 1);
-+
-+	/* create bound function object */
-+	duk_push_object_helper(ctx,
-+	                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                       DUK_HOBJECT_FLAG_BOUND |
-+	                       DUK_HOBJECT_FLAG_CONSTRUCTABLE |
-+	                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_FUNCTION),
-+	                       DUK_BIDX_FUNCTION_PROTOTYPE);
-+	h_bound = duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(h_bound != NULL);
-+
-+	/* [ thisArg arg1 ... argN func boundFunc ] */
-+	duk_dup(ctx, -2);  /* func */
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
-+
-+	duk_dup(ctx, 0);   /* thisArg */
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE);
-+
-+	duk_push_array(ctx);
-+
-+	/* [ thisArg arg1 ... argN func boundFunc argArray ] */
-+
-+	for (i = 0; i < nargs - 1; i++) {
-+		duk_dup(ctx, 1 + i);
-+		duk_put_prop_index(ctx, -2, i);
-+	}
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_ARGS, DUK_PROPDESC_FLAGS_NONE);
-+
-+	/* [ thisArg arg1 ... argN func boundFunc ] */
-+
-+	/* bound function 'length' property is interesting */
-+	h_target = duk_get_hobject(ctx, -2);
-+	if (h_target == NULL ||  /* lightfunc */
-+	    DUK_HOBJECT_GET_CLASS_NUMBER(h_target) == DUK_HOBJECT_CLASS_FUNCTION) {
-+		/* For lightfuncs, simply read the virtual property. */
-+		duk_int_t tmp;
-+		duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH);
-+		tmp = duk_to_int(ctx, -1) - (nargs - 1);  /* step 15.a */
-+		duk_pop(ctx);
-+		duk_push_int(ctx, (tmp < 0 ? 0 : tmp));
-+	} else {
-+		duk_push_int(ctx, 0);
-+	}
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);  /* attrs in E5 Section 15.3.5.1 */
-+
-+	/* caller and arguments must use the same thrower, [[ThrowTypeError]] */
-+	duk_xdef_prop_stridx_thrower(ctx, -1, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
-+	duk_xdef_prop_stridx_thrower(ctx, -1, DUK_STRIDX_LC_ARGUMENTS, DUK_PROPDESC_FLAGS_NONE);
-+
-+	/* these non-standard properties are copied for convenience */
-+	/* XXX: 'copy properties' API call? */
-+	duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_WC);
-+	duk_get_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC);
-+
-+	/* The 'strict' flag is copied to get the special [[Get]] of E5.1
-+	 * Section 15.3.5.4 to apply when a 'caller' value is a strict bound
-+	 * function.  Not sure if this is correct, because the specification
-+	 * is a bit ambiguous on this point but it would make sense.
-+	 */
-+	if (h_target == NULL) {
-+		/* Lightfuncs are always strict. */
-+		DUK_HOBJECT_SET_STRICT(h_bound);
-+	} else if (DUK_HOBJECT_HAS_STRICT(h_target)) {
-+		DUK_HOBJECT_SET_STRICT(h_bound);
-+	}
-+	DUK_DDD(DUK_DDDPRINT("created bound function: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	return 1;
-+
-+ type_error:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+#line 1 "duk_bi_global.c"
-+/*
-+ *  Global object built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Encoding/decoding helpers
-+ */
-+
-+/* Macros for creating and checking bitmasks for character encoding.
-+ * Bit number is a bit counterintuitive, but minimizes code size.
-+ */
-+#define DUK__MKBITS(a,b,c,d,e,f,g,h)  ((duk_uint8_t) ( \
-+	((a) << 0) | ((b) << 1) | ((c) << 2) | ((d) << 3) | \
-+	((e) << 4) | ((f) << 5) | ((g) << 6) | ((h) << 7) \
-+	))
-+#define DUK__CHECK_BITMASK(table,cp)  ((table)[(cp) >> 3] & (1 << ((cp) & 0x07)))
-+
-+/* E5.1 Section 15.1.3.3: uriReserved + uriUnescaped + '#' */
-+DUK_LOCAL const duk_uint8_t duk__encode_uriunescaped_table[16] = {
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
-+	DUK__MKBITS(0, 1, 0, 1, 1, 0, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  /* 0x20-0x2f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 0, 1, 0, 1),  /* 0x30-0x3f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  /* 0x40-0x4f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1),  /* 0x50-0x5f */
-+	DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  /* 0x60-0x6f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 1, 0),  /* 0x70-0x7f */
-+};
-+
-+/* E5.1 Section 15.1.3.4: uriUnescaped */
-+DUK_LOCAL const duk_uint8_t duk__encode_uricomponent_unescaped_table[16] = {
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
-+	DUK__MKBITS(0, 1, 0, 0, 0, 0, 0, 1), DUK__MKBITS(1, 1, 1, 0, 0, 1, 1, 0),  /* 0x20-0x2f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 0, 0, 0, 0, 0, 0),  /* 0x30-0x3f */
-+	DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  /* 0x40-0x4f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1),  /* 0x50-0x5f */
-+	DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  /* 0x60-0x6f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 1, 0),  /* 0x70-0x7f */
-+};
-+
-+/* E5.1 Section 15.1.3.1: uriReserved + '#' */
-+DUK_LOCAL const duk_uint8_t duk__decode_uri_reserved_table[16] = {
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
-+	DUK__MKBITS(0, 0, 0, 1, 1, 0, 1, 0), DUK__MKBITS(0, 0, 0, 1, 1, 0, 0, 1),  /* 0x20-0x2f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 1, 1, 0, 1, 0, 1),  /* 0x30-0x3f */
-+	DUK__MKBITS(1, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x40-0x4f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x50-0x5f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x60-0x6f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x70-0x7f */
-+};
-+
-+/* E5.1 Section 15.1.3.2: empty */
-+DUK_LOCAL const duk_uint8_t duk__decode_uri_component_reserved_table[16] = {
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x20-0x2f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x30-0x3f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x40-0x4f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x50-0x5f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x60-0x6f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x70-0x7f */
-+};
-+
-+#ifdef DUK_USE_SECTION_B
-+/* E5.1 Section B.2.2, step 7. */
-+DUK_LOCAL const duk_uint8_t duk__escape_unescaped_table[16] = {
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x00-0x0f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0),  /* 0x10-0x1f */
-+	DUK__MKBITS(0, 0, 0, 0, 0, 0, 0, 0), DUK__MKBITS(0, 0, 1, 1, 0, 1, 1, 1),  /* 0x20-0x2f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 0, 0, 0, 0, 0, 0),  /* 0x30-0x3f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  /* 0x40-0x4f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 1),  /* 0x50-0x5f */
-+	DUK__MKBITS(0, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1),  /* 0x60-0x6f */
-+	DUK__MKBITS(1, 1, 1, 1, 1, 1, 1, 1), DUK__MKBITS(1, 1, 1, 0, 0, 0, 0, 0)   /* 0x70-0x7f */
-+};
-+#endif  /* DUK_USE_SECTION_B */
-+
-+typedef struct {
-+	duk_hthread *thr;
-+	duk_hstring *h_str;
-+	duk_hbuffer_dynamic *h_buf;
-+	const duk_uint8_t *p;
-+	const duk_uint8_t *p_start;
-+	const duk_uint8_t *p_end;
-+} duk__transform_context;
-+
-+typedef void (*duk__transform_callback)(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp);
-+
-+/* XXX: refactor and share with other code */
-+DUK_LOCAL duk_small_int_t duk__decode_hex_escape(const duk_uint8_t *p, duk_small_int_t n) {
-+	duk_small_int_t ch;
-+	duk_small_int_t t = 0;
-+
-+	while (n > 0) {
-+		t = t * 16;
-+		ch = (duk_small_int_t) duk_hex_dectab[*p++];
-+		if (DUK_LIKELY(ch >= 0)) {
-+			t += ch;
-+		} else {
-+			return -1;
-+		}
-+		n--;
-+	}
-+	return t;
-+}
-+
-+DUK_LOCAL int duk__transform_helper(duk_context *ctx, duk__transform_callback callback, void *udata) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk__transform_context tfm_ctx_alloc;
-+	duk__transform_context *tfm_ctx = &tfm_ctx_alloc;
-+	duk_codepoint_t cp;
-+
-+	tfm_ctx->thr = thr;
-+
-+	tfm_ctx->h_str = duk_to_hstring(ctx, 0);
-+	DUK_ASSERT(tfm_ctx->h_str != NULL);
-+
-+	(void) duk_push_dynamic_buffer(ctx, 0);
-+	tfm_ctx->h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(tfm_ctx->h_buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(tfm_ctx->h_buf));
-+
-+	tfm_ctx->p_start = DUK_HSTRING_GET_DATA(tfm_ctx->h_str);
-+	tfm_ctx->p_end = tfm_ctx->p_start + DUK_HSTRING_GET_BYTELEN(tfm_ctx->h_str);
-+	tfm_ctx->p = tfm_ctx->p_start;
-+
-+	while (tfm_ctx->p < tfm_ctx->p_end) {
-+		cp = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(thr, &tfm_ctx->p, tfm_ctx->p_start, tfm_ctx->p_end);
-+		callback(tfm_ctx, udata, cp);
-+	}
-+
-+	duk_to_string(ctx, -1);
-+	return 1;
-+}
-+
-+DUK_LOCAL void duk__transform_callback_encode_uri(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) {
-+	duk_uint8_t xutf8_buf[DUK_UNICODE_MAX_XUTF8_LENGTH];
-+	duk_uint8_t buf[3];
-+	duk_small_int_t len;
-+	duk_codepoint_t cp1, cp2;
-+	duk_small_int_t i, t;
-+	const duk_uint8_t *unescaped_table = (duk_uint8_t *) udata;
-+
-+	if (cp < 0) {
-+		goto uri_error;
-+	} else if ((cp < 0x80L) && DUK__CHECK_BITMASK(unescaped_table, cp)) {
-+		duk_hbuffer_append_byte(tfm_ctx->thr, tfm_ctx->h_buf, (duk_uint8_t) cp);
-+		return;
-+	} else if (cp >= 0xdc00L && cp <= 0xdfffL) {
-+		goto uri_error;
-+	} else if (cp >= 0xd800L && cp <= 0xdbffL) {
-+		/* Needs lookahead */
-+		if (duk_unicode_decode_xutf8(tfm_ctx->thr, &tfm_ctx->p, tfm_ctx->p_start, tfm_ctx->p_end, (duk_ucodepoint_t *) &cp2) == 0) {
-+			goto uri_error;
-+		}
-+		if (!(cp2 >= 0xdc00L && cp2 <= 0xdfffL)) {
-+			goto uri_error;
-+		}
-+		cp1 = cp;
-+		cp = ((cp1 - 0xd800L) << 10) + (cp2 - 0xdc00L) + 0x10000L;
-+	} else if (cp > 0x10ffffL) {
-+		/* Although we can allow non-BMP characters (they'll decode
-+		 * back into surrogate pairs), we don't allow extended UTF-8
-+		 * characters; they would encode to URIs which won't decode
-+		 * back because of strict UTF-8 checks in URI decoding.
-+		 * (However, we could just as well allow them here.)
-+		 */
-+		goto uri_error;
-+	} else {
-+		/* Non-BMP characters within valid UTF-8 range: encode as is.
-+		 * They'll decode back into surrogate pairs.
-+		 */
-+		;
-+	}
-+
-+	len = duk_unicode_encode_xutf8((duk_ucodepoint_t) cp, xutf8_buf);
-+	buf[0] = (duk_uint8_t) '%';
-+	for (i = 0; i < len; i++) {
-+		t = (int) xutf8_buf[i];
-+		buf[1] = (duk_uint8_t) duk_uc_nybbles[t >> 4];
-+		buf[2] = (duk_uint8_t) duk_uc_nybbles[t & 0x0f];
-+		duk_hbuffer_append_bytes(tfm_ctx->thr, tfm_ctx->h_buf, buf, 3);
-+	}
-+	return;
-+
-+ uri_error:
-+	DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input");
-+}
-+
-+DUK_LOCAL void duk__transform_callback_decode_uri(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) {
-+	const duk_uint8_t *reserved_table = (duk_uint8_t *) udata;
-+	duk_small_uint_t utf8_blen;
-+	duk_codepoint_t min_cp;
-+	duk_small_int_t t;  /* must be signed */
-+	duk_small_uint_t i;
-+
-+	if (cp == (duk_codepoint_t) '%') {
-+		const duk_uint8_t *p = tfm_ctx->p;
-+		duk_size_t left = (duk_size_t) (tfm_ctx->p_end - p);  /* bytes left */
-+
-+		DUK_DDD(DUK_DDDPRINT("percent encoding, left=%ld", (long) left));
-+
-+		if (left < 2) {
-+			goto uri_error;
-+		}
-+
-+		t = duk__decode_hex_escape(p, 2);
-+		DUK_DDD(DUK_DDDPRINT("first byte: %ld", (long) t));
-+		if (t < 0) {
-+			goto uri_error;
-+		}
-+
-+		if (t < 0x80) {
-+			if (DUK__CHECK_BITMASK(reserved_table, t)) {
-+				/* decode '%xx' to '%xx' if decoded char in reserved set */
-+				DUK_ASSERT(tfm_ctx->p - 1 >= tfm_ctx->p_start);
-+				duk_hbuffer_append_bytes(tfm_ctx->thr, tfm_ctx->h_buf, (duk_uint8_t *) (p - 1), 3);
-+			} else {
-+				duk_hbuffer_append_byte(tfm_ctx->thr, tfm_ctx->h_buf, (duk_uint8_t) t);
-+			}
-+			tfm_ctx->p += 2;
-+			return;
-+		}
-+
-+		/* Decode UTF-8 codepoint from a sequence of hex escapes.  The
-+		 * first byte of the sequence has been decoded to 't'.
-+		 *
-+		 * Note that UTF-8 validation must be strict according to the
-+		 * specification: E5.1 Section 15.1.3, decode algorithm step
-+		 * 4.d.vii.8.  URIError from non-shortest encodings is also
-+		 * specifically noted in the spec.
-+		 */
-+
-+		DUK_ASSERT(t >= 0x80);
-+		if (t < 0xc0) {
-+			/* continuation byte */
-+			goto uri_error;
-+		} else if (t < 0xe0) {
-+			/* 110x xxxx; 2 bytes */
-+			utf8_blen = 2;
-+			min_cp = 0x80L;
-+			cp = t & 0x1f;
-+		} else if (t < 0xf0) {
-+			/* 1110 xxxx; 3 bytes */
-+			utf8_blen = 3;
-+			min_cp = 0x800L;
-+			cp = t & 0x0f;
-+		} else if (t < 0xf8) {
-+			/* 1111 0xxx; 4 bytes */
-+			utf8_blen = 4;
-+			min_cp = 0x10000L;
-+			cp = t & 0x07;
-+		} else {
-+			/* extended utf-8 not allowed for URIs */
-+			goto uri_error;
-+		}
-+
-+		if (left < utf8_blen * 3 - 1) {
-+			/* '%xx%xx...%xx', p points to char after first '%' */
-+			goto uri_error;
-+		}
-+
-+		p += 3;
-+		for (i = 1; i < utf8_blen; i++) {
-+			/* p points to digit part ('%xy', p points to 'x') */
-+			t = duk__decode_hex_escape(p, 2);
-+			DUK_DDD(DUK_DDDPRINT("i=%ld utf8_blen=%ld cp=%ld t=0x%02lx",
-+			                     (long) i, (long) utf8_blen, (long) cp, (unsigned long) t));
-+			if (t < 0) {
-+				goto uri_error;
-+			}
-+			if ((t & 0xc0) != 0x80) {
-+				goto uri_error;
-+			}
-+			cp = (cp << 6) + (t & 0x3f);
-+			p += 3;
-+		}
-+		p--;  /* p overshoots */
-+		tfm_ctx->p = p;
-+
-+		DUK_DDD(DUK_DDDPRINT("final cp=%ld, min_cp=%ld", (long) cp, (long) min_cp));
-+
-+		if (cp < min_cp || cp > 0x10ffffL || (cp >= 0xd800L && cp <= 0xdfffL)) {
-+			goto uri_error;
-+		}
-+
-+		/* The E5.1 algorithm checks whether or not a decoded codepoint
-+		 * is below 0x80 and perhaps may be in the "reserved" set.
-+		 * This seems pointless because the single byte UTF-8 case is
-+		 * handled separately, and non-shortest encodings are rejected.
-+		 * So, 'cp' cannot be below 0x80 here, and thus cannot be in
-+		 * the reserved set.
-+		 */
-+
-+		/* utf-8 validation ensures these */
-+		DUK_ASSERT(cp >= 0x80L && cp <= 0x10ffffL);
-+
-+		if (cp >= 0x10000L) {
-+			cp -= 0x10000L;
-+			DUK_ASSERT(cp < 0x100000L);
-+			duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, (duk_ucodepoint_t) ((cp >> 10) + 0xd800L));
-+			duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, (duk_ucodepoint_t) ((cp & 0x03ffUL) + 0xdc00L));
-+		} else {
-+			duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, (duk_ucodepoint_t) cp);
-+		}
-+	} else {
-+		duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, (duk_ucodepoint_t) cp);
-+	}
-+	return;
-+
-+ uri_error:
-+	DUK_ERROR(tfm_ctx->thr, DUK_ERR_URI_ERROR, "invalid input");
-+}
-+
-+#ifdef DUK_USE_SECTION_B
-+DUK_LOCAL void duk__transform_callback_escape(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) {
-+	duk_uint8_t buf[6];
-+	duk_small_int_t len;
-+
-+	DUK_UNREF(udata);
-+
-+	if (cp < 0) {
-+		goto esc_error;
-+	} else if ((cp < 0x80L) && DUK__CHECK_BITMASK(duk__escape_unescaped_table, cp)) {
-+		buf[0] = (duk_uint8_t) cp;
-+		len = 1;
-+	} else if (cp < 0x100L) {
-+		buf[0] = (duk_uint8_t) '%';
-+		buf[1] = (duk_uint8_t) duk_uc_nybbles[cp >> 4];
-+		buf[2] = (duk_uint8_t) duk_uc_nybbles[cp & 0x0f];
-+		len = 3;
-+	} else if (cp < 0x10000L) {
-+		buf[0] = (duk_uint8_t) '%';
-+		buf[1] = (duk_uint8_t) 'u';
-+		buf[2] = (duk_uint8_t) duk_uc_nybbles[cp >> 12];
-+		buf[3] = (duk_uint8_t) duk_uc_nybbles[(cp >> 8) & 0x0f];
-+		buf[4] = (duk_uint8_t) duk_uc_nybbles[(cp >> 4) & 0x0f];
-+		buf[5] = (duk_uint8_t) duk_uc_nybbles[cp & 0x0f];
-+		len = 6;
-+	} else {
-+		/* Characters outside BMP cannot be escape()'d.  We could
-+		 * encode them as surrogate pairs (for codepoints inside
-+		 * valid UTF-8 range, but not extended UTF-8).  Because
-+		 * escape() and unescape() are legacy functions, we don't.
-+		 */
-+		goto esc_error;
-+	}
-+
-+	duk_hbuffer_append_bytes(tfm_ctx->thr, tfm_ctx->h_buf, buf, len);
-+	return;
-+
-+ esc_error:
-+	DUK_ERROR(tfm_ctx->thr, DUK_ERR_TYPE_ERROR, "invalid input");
-+}
-+
-+DUK_LOCAL void duk__transform_callback_unescape(duk__transform_context *tfm_ctx, void *udata, duk_codepoint_t cp) {
-+	duk_small_int_t t;
-+
-+	DUK_UNREF(udata);
-+
-+	if (cp == (duk_codepoint_t) '%') {
-+		const duk_uint8_t *p = tfm_ctx->p;
-+		duk_size_t left = (duk_size_t) (tfm_ctx->p_end - p);  /* bytes left */
-+
-+		if (left >= 5 && p[0] == 'u' &&
-+		    ((t = duk__decode_hex_escape(p + 1, 4)) >= 0)) {
-+			cp = (duk_codepoint_t) t;
-+			tfm_ctx->p += 5;
-+		} else if (left >= 2 &&
-+		           ((t = duk__decode_hex_escape(p, 2)) >= 0)) {
-+			cp = (duk_codepoint_t) t;
-+			tfm_ctx->p += 2;
-+		}
-+	}
-+
-+	duk_hbuffer_append_xutf8(tfm_ctx->thr, tfm_ctx->h_buf, cp);
-+}
-+#endif  /* DUK_USE_SECTION_B */
-+
-+/*
-+ *  Eval
-+ *
-+ *  Eval needs to handle both a "direct eval" and an "indirect eval".
-+ *  Direct eval handling needs access to the caller's activation so that its
-+ *  lexical environment can be accessed.  A direct eval is only possible from
-+ *  Ecmascript code; an indirect eval call is possible also from C code.
-+ *  When an indirect eval call is made from C code, there may not be a
-+ *  calling activation at all which needs careful handling.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_eval(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h;
-+	duk_activation *act_caller;
-+	duk_activation *act_eval;
-+	duk_activation *act;
-+	duk_hcompiledfunction *func;
-+	duk_hobject *outer_lex_env;
-+	duk_hobject *outer_var_env;
-+	duk_bool_t this_to_global = 1;
-+	duk_small_uint_t comp_flags;
-+
-+	DUK_ASSERT_TOP(ctx, 1);
-+	DUK_ASSERT(thr->callstack_top >= 1);  /* at least this function exists */
-+	DUK_ASSERT(((thr->callstack + thr->callstack_top - 1)->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0 || /* indirect eval */
-+	           (thr->callstack_top >= 2));  /* if direct eval, calling activation must exist */
-+
-+	/*
-+	 *  callstack_top - 1 --> this function
-+	 *  callstack_top - 2 --> caller (may not exist)
-+	 *
-+	 *  If called directly from C, callstack_top might be 1.  If calling
-+	 *  activation doesn't exist, call must be indirect.
-+	 */
-+
-+	h = duk_get_hstring(ctx, 0);
-+	if (!h) {
-+		return 1;  /* return arg as-is */
-+	}
-+
-+	/* [ source ] */
-+
-+	comp_flags = DUK_JS_COMPILE_FLAG_EVAL;
-+	act_eval = thr->callstack + thr->callstack_top - 1;    /* this function */
-+	if (thr->callstack_top >= 2) {
-+		/* Have a calling activation, check for direct eval (otherwise
-+		 * assume indirect eval.
-+		 */
-+		act_caller = thr->callstack + thr->callstack_top - 2;  /* caller */
-+		if ((act_caller->flags & DUK_ACT_FLAG_STRICT) &&
-+		    (act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL)) {
-+			/* Only direct eval inherits strictness from calling code
-+			 * (E5.1 Section 10.1.1).
-+			 */
-+			comp_flags |= DUK_JS_COMPILE_FLAG_STRICT;
-+		}
-+	} else {
-+		DUK_ASSERT((act_eval->flags & DUK_ACT_FLAG_DIRECT_EVAL) == 0);
-+	}
-+	act_caller = NULL;  /* avoid dereference after potential callstack realloc */
-+	act_eval = NULL;
-+
-+	duk_push_hstring_stridx(ctx, DUK_STRIDX_INPUT);  /* XXX: copy from caller? */
-+	duk_js_compile(thr,
-+	               (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h),
-+	               (duk_size_t) DUK_HSTRING_GET_BYTELEN(h),
-+	               comp_flags);
-+	func = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) func));
-+
-+	/* [ source template ] */
-+
-+	/* E5 Section 10.4.2 */
-+	DUK_ASSERT(thr->callstack_top >= 1);
-+	act = thr->callstack + thr->callstack_top - 1;  /* this function */
-+	if (act->flags & DUK_ACT_FLAG_DIRECT_EVAL) {
-+		DUK_ASSERT(thr->callstack_top >= 2);
-+		act = thr->callstack + thr->callstack_top - 2;  /* caller */
-+		if (act->lex_env == NULL) {
-+			DUK_ASSERT(act->var_env == NULL);
-+			DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
-+
-+			/* this may have side effects, so re-lookup act */
-+			duk_js_init_activation_environment_records_delayed(thr, act);
-+			act = thr->callstack + thr->callstack_top - 2;
-+		}
-+		DUK_ASSERT(act->lex_env != NULL);
-+		DUK_ASSERT(act->var_env != NULL);
-+
-+		this_to_global = 0;
-+
-+		if (DUK_HOBJECT_HAS_STRICT((duk_hobject *) func)) {
-+			duk_hobject *new_env;
-+			duk_hobject *act_lex_env;
-+
-+			DUK_DDD(DUK_DDDPRINT("direct eval call to a strict function -> "
-+			                     "var_env and lex_env to a fresh env, "
-+			                     "this_binding to caller's this_binding"));
-+
-+			act = thr->callstack + thr->callstack_top - 2;  /* caller */
-+			act_lex_env = act->lex_env;
-+			act = NULL;  /* invalidated */
-+
-+			(void) duk_push_object_helper_proto(ctx,
-+			                                    DUK_HOBJECT_FLAG_EXTENSIBLE |
-+			                                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
-+			                                    act_lex_env);
-+			new_env = duk_require_hobject(ctx, -1);
-+			DUK_ASSERT(new_env != NULL);
-+			DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO",
-+			                     (duk_heaphdr *) new_env));
-+
-+			outer_lex_env = new_env;
-+			outer_var_env = new_env;
-+
-+			duk_insert(ctx, 0);  /* stash to bottom of value stack to keep new_env reachable */
-+
-+			/* compiler's responsibility */
-+			DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV((duk_hobject *) func));
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("direct eval call to a non-strict function -> "
-+			                     "var_env and lex_env to caller's envs, "
-+			                     "this_binding to caller's this_binding"));
-+
-+			outer_lex_env = act->lex_env;
-+			outer_var_env = act->var_env;
-+
-+			/* compiler's responsibility */
-+			DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV((duk_hobject *) func));
-+		}
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("indirect eval call -> var_env and lex_env to "
-+		                     "global object, this_binding to global object"));
-+
-+		this_to_global = 1;
-+		outer_lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+		outer_var_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+	}
-+	act = NULL;
-+
-+	duk_js_push_closure(thr, func, outer_var_env, outer_lex_env);
-+
-+	/* [ source template closure ] */
-+
-+	if (this_to_global) {
-+		DUK_ASSERT(thr->builtins[DUK_BIDX_GLOBAL] != NULL);
-+		duk_push_hobject_bidx(ctx, DUK_BIDX_GLOBAL);
-+	} else {
-+		duk_tval *tv;
-+		DUK_ASSERT(thr->callstack_top >= 2);
-+		act = thr->callstack + thr->callstack_top - 2;  /* caller */
-+		tv = thr->valstack + act->idx_bottom - 1;  /* this is just beneath bottom */
-+		DUK_ASSERT(tv >= thr->valstack);
-+		duk_push_tval(ctx, tv);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("eval -> lex_env=%!iO, var_env=%!iO, this_binding=%!T",
-+	                     (duk_heaphdr *) outer_lex_env,
-+	                     (duk_heaphdr *) outer_var_env,
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/* [ source template closure this ] */
-+
-+	duk_call_method(ctx, 0);
-+
-+	/* [ source template result ] */
-+
-+	return 1;
-+}
-+
-+/*
-+ *  Parsing of ints and floats
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_parse_int(duk_context *ctx) {
-+	duk_bool_t strip_prefix;
-+	duk_int32_t radix;
-+	duk_small_uint_t s2n_flags;
-+
-+	DUK_ASSERT_TOP(ctx, 2);
-+	duk_to_string(ctx, 0);
-+
-+	strip_prefix = 1;
-+	radix = duk_to_int32(ctx, 1);
-+	if (radix != 0) {
-+		if (radix < 2 || radix > 36) {
-+			goto ret_nan;
-+		}
-+		/* For octal, setting strip_prefix=0 is not necessary, as zero
-+		 * is tolerated anyway:
-+		 *
-+		 *   parseInt('123', 8) === parseInt('0123', 8)     with or without strip_prefix
-+		 *   parseInt('123', 16) === parseInt('0x123', 16)  requires strip_prefix = 1
-+		 */
-+		if (radix != 16) {
-+			strip_prefix = 0;
-+		}
-+	} else {
-+		radix = 10;
-+	}
-+
-+	s2n_flags = DUK_S2N_FLAG_TRIM_WHITE |
-+	            DUK_S2N_FLAG_ALLOW_GARBAGE |
-+	            DUK_S2N_FLAG_ALLOW_PLUS |
-+	            DUK_S2N_FLAG_ALLOW_MINUS |
-+	            DUK_S2N_FLAG_ALLOW_LEADING_ZERO |
-+#ifdef DUK_USE_OCTAL_SUPPORT
-+	            (strip_prefix ? (DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT | DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT) : 0)
-+#else
-+	            (strip_prefix ? DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT : 0)
-+#endif
-+	            ;
-+
-+	duk_dup(ctx, 0);
-+	duk_numconv_parse(ctx, radix, s2n_flags);
-+	return 1;
-+
-+ ret_nan:
-+	duk_push_nan(ctx);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_parse_float(duk_context *ctx) {
-+	duk_small_uint_t s2n_flags;
-+	duk_int32_t radix;
-+
-+	DUK_ASSERT_TOP(ctx, 1);
-+	duk_to_string(ctx, 0);
-+
-+	radix = 10;
-+
-+	/* XXX: check flags */
-+	s2n_flags = DUK_S2N_FLAG_TRIM_WHITE |
-+	            DUK_S2N_FLAG_ALLOW_EXP |
-+	            DUK_S2N_FLAG_ALLOW_GARBAGE |
-+	            DUK_S2N_FLAG_ALLOW_PLUS |
-+	            DUK_S2N_FLAG_ALLOW_MINUS |
-+	            DUK_S2N_FLAG_ALLOW_INF |
-+	            DUK_S2N_FLAG_ALLOW_FRAC |
-+	            DUK_S2N_FLAG_ALLOW_NAKED_FRAC |
-+	            DUK_S2N_FLAG_ALLOW_EMPTY_FRAC |
-+	            DUK_S2N_FLAG_ALLOW_LEADING_ZERO;
-+
-+	duk_numconv_parse(ctx, radix, s2n_flags);
-+	return 1;
-+}
-+
-+/*
-+ *  Number checkers
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_is_nan(duk_context *ctx) {
-+	duk_double_t d = duk_to_number(ctx, 0);
-+	duk_push_boolean(ctx, DUK_ISNAN(d));
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_is_finite(duk_context *ctx) {
-+	duk_double_t d = duk_to_number(ctx, 0);
-+	duk_push_boolean(ctx, DUK_ISFINITE(d));
-+	return 1;
-+}
-+
-+/*
-+ *  URI handling
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_decode_uri(duk_context *ctx) {
-+	return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (void *) duk__decode_uri_reserved_table);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_decode_uri_component(duk_context *ctx) {
-+	return duk__transform_helper(ctx, duk__transform_callback_decode_uri, (void *) duk__decode_uri_component_reserved_table);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_encode_uri(duk_context *ctx) {
-+	return duk__transform_helper(ctx, duk__transform_callback_encode_uri, (void *) duk__encode_uriunescaped_table);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_encode_uri_component(duk_context *ctx) {
-+	return duk__transform_helper(ctx, duk__transform_callback_encode_uri, (void *) duk__encode_uricomponent_unescaped_table);
-+}
-+
-+#ifdef DUK_USE_SECTION_B
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_escape(duk_context *ctx) {
-+	return duk__transform_helper(ctx, duk__transform_callback_escape, (void *) NULL);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx) {
-+	return duk__transform_helper(ctx, duk__transform_callback_unescape, (void *) NULL);
-+}
-+#else  /* DUK_USE_SECTION_B */
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_escape(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_unescape(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+#endif  /* DUK_USE_SECTION_B */
-+
-+#if defined(DUK_USE_BROWSER_LIKE) && (defined(DUK_USE_FILE_IO) || defined(DUK_USE_DEBUGGER_SUPPORT))
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_int_t magic;
-+	duk_idx_t nargs;
-+	const duk_uint8_t *buf;
-+	duk_size_t sz_buf;
-+	const char nl = (const char) DUK_ASC_LF;
-+#ifndef DUK_USE_PREFER_SIZE
-+	duk_uint8_t buf_stack[256];
-+#endif
-+#ifdef DUK_USE_FILE_IO
-+	duk_file *f_out;
-+#endif
-+
-+	magic = duk_get_current_magic(ctx);
-+	DUK_UNREF(magic);
-+
-+	nargs = duk_get_top(ctx);
-+
-+	/* If argument count is 1 and first argument is a buffer, write the buffer
-+	 * as raw data into the file without a newline; this allows exact control
-+	 * over stdout/stderr without an additional entrypoint (useful for now).
-+	 *
-+	 * Otherwise current print/alert semantics are to ToString() coerce
-+	 * arguments, join them with a single space, and append a newline.
-+	 */
-+
-+	if (nargs == 1 && duk_is_buffer(ctx, 0)) {
-+		buf = (const duk_uint8_t *) duk_get_buffer(ctx, 0, &sz_buf);
-+		DUK_ASSERT(buf != NULL);
-+	} else if (nargs > 0) {
-+#ifdef DUK_USE_PREFER_SIZE
-+		/* Compact but lots of churn. */
-+		duk_push_hstring_stridx(thr, DUK_STRIDX_SPACE);
-+		duk_insert(ctx, 0);
-+		duk_join(ctx, nargs);
-+		duk_push_string(thr, "\n");
-+		duk_concat(ctx, 2);
-+		buf = (const duk_uint8_t *) duk_get_lstring(ctx, -1, &sz_buf);
-+		DUK_ASSERT(buf != NULL);
-+#else  /* DUK_USE_PREFER_SIZE */
-+		/* Higher footprint, less churn. */
-+		duk_idx_t i;
-+		duk_size_t sz_str;
-+		const duk_uint8_t *p_str;
-+		duk_uint8_t *p;
-+
-+		sz_buf = (duk_size_t) nargs;  /* spaces (nargs - 1) + newline */
-+		for (i = 0; i < nargs; i++) {
-+			(void) duk_to_lstring(ctx, i, &sz_str);
-+			sz_buf += sz_str;
-+		}
-+
-+		if (sz_buf <= sizeof(buf_stack)) {
-+			buf = (const duk_uint8_t *) buf_stack;
-+		} else {
-+			buf = (const duk_uint8_t *) duk_push_fixed_buffer(ctx, sz_buf);
-+			DUK_ASSERT(buf != NULL);
-+		}
-+
-+		p = (duk_uint8_t *) buf;
-+		for (i = 0; i < nargs; i++) {
-+			p_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &sz_str);
-+			DUK_ASSERT(p_str != NULL);
-+			DUK_MEMCPY((void *) p, (const void *) p_str, sz_str);
-+			p += sz_str;
-+			*p++ = (duk_uint8_t) (i == nargs - 1 ? DUK_ASC_LF : DUK_ASC_SPACE);
-+		}
-+		DUK_ASSERT((const duk_uint8_t *) p == buf + sz_total);
-+#endif  /* DUK_USE_PREFER_SIZE */
-+	} else {
-+		buf = (const duk_uint8_t *) &nl;
-+		sz_buf = 1;
-+	}
-+
-+	/* 'buf' contains the string to write, 'sz_buf' contains the length
-+	 * (which may be zero).
-+	 */
-+	DUK_ASSERT(buf != NULL);
-+
-+	if (sz_buf == 0) {
-+		return 0;
-+	}
-+
-+#ifdef DUK_USE_FILE_IO
-+	f_out = (magic ? DUK_STDERR : DUK_STDOUT);
-+	DUK_FWRITE((const void *) buf, 1, (size_t) sz_buf, f_out);
-+	DUK_FFLUSH(f_out);
-+#endif
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT) && defined(DUK_USE_DEBUGGER_FWD_PRINTALERT)
-+	if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
-+		duk_debug_write_notify(thr, magic ? DUK_DBG_CMD_ALERT : DUK_DBG_CMD_PRINT);
-+		duk_debug_write_string(thr, (const char *) buf, sz_buf);
-+		duk_debug_write_eom(thr);
-+	}
-+#endif
-+	return 0;
-+}
-+#elif defined(DUK_USE_BROWSER_LIKE)  /* print provider */
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return 0;
-+}
-+#else  /* print provider */
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_print_helper(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+#endif  /* print provider */
-+
-+/*
-+ *  CommonJS require() and modules support
-+ */
-+
-+#if defined(DUK_USE_COMMONJS_MODULES)
-+DUK_LOCAL void duk__bi_global_resolve_module_id(duk_context *ctx, const char *req_id, const char *mod_id) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_size_t mod_id_len;
-+	duk_size_t req_id_len;
-+	duk_uint8_t buf_in[DUK_BI_COMMONJS_MODULE_ID_LIMIT];
-+	duk_uint8_t buf_out[DUK_BI_COMMONJS_MODULE_ID_LIMIT];
-+	duk_uint8_t *p;
-+	duk_uint8_t *q;
-+
-+	DUK_ASSERT(req_id != NULL);
-+	/* mod_id may be NULL */
-+	DUK_ASSERT(sizeof(buf_out) >= sizeof(buf_in));  /* bound checking requires this */
-+
-+	/*
-+	 *  A few notes on the algorithm:
-+	 *
-+	 *    - Terms are not allowed to begin with a period unless the term
-+	 *      is either '.' or '..'.  This simplifies implementation (and
-+	 *      is within CommonJS modules specification).
-+	 *
-+	 *    - There are few output bound checks here.  This is on purpose:
-+	 *      we check the input length and rely on the output never being
-+	 *      longer than the input, so we cannot run out of output space.
-+	 *
-+	 *    - Non-ASCII characters are processed as individual bytes and
-+	 *      need no special treatment.  However, U+0000 terminates the
-+	 *      algorithm; this is not an issue because U+0000 is not a
-+	 *      desirable term character anyway.
-+	 */
-+
-+	/*
-+	 *  Set up the resolution input which is the requested ID directly
-+	 *  (if absolute or no current module path) or with current module
-+	 *  ID prepended (if relative and current module path exists).
-+	 *
-+	 *  Suppose current module is 'foo/bar' and relative path is './quux'.
-+	 *  The 'bar' component must be replaced so the initial input here is
-+	 *  'foo/bar/.././quux'.
-+	 */
-+
-+	req_id_len = DUK_STRLEN(req_id);
-+	if (mod_id != NULL && req_id[0] == '.') {
-+		mod_id_len = DUK_STRLEN(mod_id);
-+		if (mod_id_len + 4 + req_id_len + 1 >= sizeof(buf_in)) {
-+			DUK_DD(DUK_DDPRINT("resolve error: current and requested module ID don't fit into resolve input buffer"));
-+			goto resolve_error;
-+		}
-+		(void) DUK_SNPRINTF((char *) buf_in, sizeof(buf_in), "%s/../%s", (const char *) mod_id, (const char *) req_id);
-+	} else {
-+		if (req_id_len + 1 >= sizeof(buf_in)) {
-+			DUK_DD(DUK_DDPRINT("resolve error: requested module ID doesn't fit into resolve input buffer"));
-+			goto resolve_error;
-+		}
-+		(void) DUK_SNPRINTF((char *) buf_in, sizeof(buf_in), "%s", (const char *) req_id);
-+	}
-+	buf_in[sizeof(buf_in) - 1] = (duk_uint8_t) 0;
-+
-+	DUK_DDD(DUK_DDDPRINT("input module id: '%s'", (const char *) buf_in));
-+
-+	/*
-+	 *  Resolution loop.  At the top of the loop we're expecting a valid
-+	 *  term: '.', '..', or a non-empty identifier not starting with a period.
-+	 */
-+
-+	p = buf_in;
-+	q = buf_out;
-+	for (;;) {
-+		duk_uint_fast8_t c;
-+
-+		/* Here 'p' always points to the start of a term. */
-+		DUK_DDD(DUK_DDDPRINT("resolve loop top: p -> '%s', q=%p, buf_out=%p",
-+		                     (const char *) p, (void *) q, (void *) buf_out));
-+
-+		c = *p++;
-+		if (DUK_UNLIKELY(c == 0)) {
-+			DUK_DD(DUK_DDPRINT("resolve error: requested ID must end with a non-empty term"));
-+			goto resolve_error;
-+		} else if (DUK_UNLIKELY(c == '.')) {
-+			c = *p++;
-+			if (c == '/') {
-+				/* Term was '.' and is eaten entirely (including dup slashes). */
-+				goto eat_dup_slashes;
-+			}
-+			if (c == '.' && *p == '/') {
-+				/* Term was '..', backtrack resolved name by one component.
-+				 *  q[-1] = previous slash (or beyond start of buffer)
-+				 *  q[-2] = last char of previous component (or beyond start of buffer)
-+				 */
-+				p++;  /* eat (first) input slash */
-+				DUK_ASSERT(q >= buf_out);
-+				if (q == buf_out) {
-+					DUK_DD(DUK_DDPRINT("resolve error: term was '..' but nothing to backtrack"));
-+					goto resolve_error;
-+				}
-+				DUK_ASSERT(*(q - 1) == '/');
-+				q--;  /* backtrack to last output slash */
-+				for (;;) {
-+					/* Backtrack to previous slash or start of buffer. */
-+					DUK_ASSERT(q >= buf_out);
-+					if (q == buf_out) {
-+						break;
-+					}
-+					if (*(q - 1) == '/') {
-+						break;
-+					}
-+					q--;
-+				}
-+				goto eat_dup_slashes;
-+			}
-+			DUK_DD(DUK_DDPRINT("resolve error: term begins with '.' but is not '.' or '..' (not allowed now)"));
-+			goto resolve_error;
-+		} else if (DUK_UNLIKELY(c == '/')) {
-+			/* e.g. require('/foo'), empty terms not allowed */
-+			DUK_DD(DUK_DDPRINT("resolve error: empty term (not allowed now)"));
-+			goto resolve_error;
-+		} else {
-+			for (;;) {
-+				/* Copy term name until end or '/'. */
-+				*q++ = c;
-+				c = *p++;
-+				if (DUK_UNLIKELY(c == 0)) {
-+					goto loop_done;
-+				} else if (DUK_UNLIKELY(c == '/')) {
-+					*q++ = '/';
-+					break;
-+				} else {
-+					/* write on next loop */
-+				}
-+			}
-+		}
-+
-+	 eat_dup_slashes:
-+		for (;;) {
-+			/* eat dup slashes */
-+			c = *p;
-+			if (DUK_LIKELY(c != '/')) {
-+				break;
-+			}
-+			p++;
-+		}
-+	}
-+ loop_done:
-+
-+	duk_push_lstring(ctx, (const char *) buf_out, (size_t) (q - buf_out));
-+	return;
-+
-+ resolve_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "cannot resolve module id: %s", (const char *) req_id);
-+}
-+#endif  /* DUK_USE_COMMONJS_MODULES */
-+
-+#if defined(DUK_USE_COMMONJS_MODULES)
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) {
-+	const char *str_req_id;  /* requested identifier */
-+	const char *str_mod_id;  /* require.id of current module */
-+
-+	/* NOTE: we try to minimize code size by avoiding unnecessary pops,
-+	 * so the stack looks a bit cluttered in this function.  DUK_ASSERT_TOP()
-+	 * assertions are used to ensure stack configuration is correct at each
-+	 * step.
-+	 */
-+
-+	/*
-+	 *  Resolve module identifier into canonical absolute form.
-+	 */
-+
-+	str_req_id = duk_require_string(ctx, 0);
-+	duk_push_current_function(ctx);
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_ID);
-+	str_mod_id = duk_get_string(ctx, 2);  /* ignore non-strings */
-+	DUK_DDD(DUK_DDDPRINT("resolve module id: requested=%!T, currentmodule=%!T",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 2)));
-+	duk__bi_global_resolve_module_id(ctx, str_req_id, str_mod_id);
-+	str_req_id = NULL;
-+	str_mod_id = NULL;
-+	DUK_DDD(DUK_DDDPRINT("resolved module id: requested=%!T, currentmodule=%!T, result=%!T",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 2),
-+	                     (duk_tval *) duk_get_tval(ctx, 3)));
-+
-+	/* [ requested_id require require.id resolved_id ] */
-+	DUK_ASSERT_TOP(ctx, 4);
-+
-+	/*
-+	 *  Cached module check.
-+	 *
-+	 *  If module has been loaded or its loading has already begun without
-+	 *  finishing, return the same cached value ('exports').  The value is
-+	 *  registered when module load starts so that circular references can
-+	 *  be supported to some extent.
-+	 */
-+
-+	/* [ requested_id require require.id resolved_id ] */
-+	DUK_ASSERT_TOP(ctx, 4);
-+
-+	duk_push_hobject_bidx(ctx, DUK_BIDX_DUKTAPE);
-+	duk_get_prop_stridx(ctx, 4, DUK_STRIDX_MOD_LOADED);  /* Duktape.modLoaded */
-+	(void) duk_require_hobject(ctx, 5);
-+
-+	/* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded ] */
-+	DUK_ASSERT_TOP(ctx, 6);
-+
-+	duk_dup(ctx, 3);
-+	if (duk_get_prop(ctx, 5)) {
-+		/* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded Duktape.modLoaded[id] ] */
-+		DUK_DD(DUK_DDPRINT("module already loaded: %!T",
-+		                   (duk_tval *) duk_get_tval(ctx, 3)));
-+		return 1;
-+	}
-+
-+	/* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined ] */
-+	DUK_ASSERT_TOP(ctx, 7);
-+
-+	/*
-+	 *  Module not loaded (and loading not started previously).
-+	 *
-+	 *  Create a new require() function with 'id' set to resolved ID
-+	 *  of module being loaded.  Also create 'exports' and 'module'
-+	 *  tables but don't register exports to the loaded table yet.
-+	 *  We don't want to do that unless the user module search callbacks
-+	 *  succeeds in finding the module.
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("module not yet loaded: %!T",
-+	                   (duk_tval *) duk_get_tval(ctx, 3)));
-+
-+	/* Fresh require: require.id is left configurable (but not writable)
-+	 * so that is not easy to accidentally tweak it, but it can still be
-+	 * done with Object.defineProperty().
-+	 *
-+	 * XXX: require.id could also be just made non-configurable, as there
-+	 * is no practical reason to touch it.
-+	 */
-+	duk_push_c_function(ctx, duk_bi_global_object_require, 1 /*nargs*/);
-+	duk_dup(ctx, 3);
-+	duk_xdef_prop_stridx(ctx, 7, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_C);  /* a fresh require() with require.id = resolved target module id */
-+
-+	/* Exports table. */
-+	duk_push_object(ctx);
-+
-+	/* Module table: module.id is non-writable and non-configurable, as
-+	 * the CommonJS spec suggests this if possible.
-+	 */
-+	duk_push_object(ctx);
-+	duk_dup(ctx, 3);  /* resolved id: require(id) must return this same module */
-+	duk_xdef_prop_stridx(ctx, 9, DUK_STRIDX_ID, DUK_PROPDESC_FLAGS_NONE);
-+
-+	/* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module ] */
-+	DUK_ASSERT_TOP(ctx, 10);
-+
-+	/*
-+	 *  Call user provided module search function and build the wrapped
-+	 *  module source code (if necessary).  The module search function
-+	 *  can be used to implement pure Ecmacsript, pure C, and mixed
-+	 *  Ecmascript/C modules.
-+	 *
-+	 *  The module search function can operate on the exports table directly
-+	 *  (e.g. DLL code can register values to it).  It can also return a
-+	 *  string which is interpreted as module source code (if a non-string
-+	 *  is returned the module is assumed to be a pure C one).  If a module
-+	 *  cannot be found, an error must be thrown by the user callback.
-+	 *
-+	 *  NOTE: the current arrangement allows C modules to be implemented
-+	 *  but since the exports table is registered to Duktape.modLoaded only
-+	 *  after the search function returns, circular requires / partially
-+	 *  loaded modules don't work for C modules.  This is rarely an issue,
-+	 *  as C modules usually simply expose a set of helper functions.
-+	 */
-+
-+	duk_push_string(ctx, "(function(require,exports,module){");
-+
-+	/* Duktape.modSearch(resolved_id, fresh_require, exports, module). */
-+	duk_get_prop_stridx(ctx, 4, DUK_STRIDX_MOD_SEARCH);  /* Duktape.modSearch */
-+	duk_dup(ctx, 3);
-+	duk_dup(ctx, 7);
-+	duk_dup(ctx, 8);
-+	duk_dup(ctx, 9);  /* [ ... Duktape.modSearch resolved_id fresh_require exports module ] */
-+	duk_call(ctx, 4 /*nargs*/);  /* -> [ ... source ] */
-+	DUK_ASSERT_TOP(ctx, 12);
-+
-+	/* Because user callback did not throw an error, remember exports table. */
-+	duk_dup(ctx, 3);
-+	duk_dup(ctx, 8);
-+	duk_xdef_prop(ctx, 5, DUK_PROPDESC_FLAGS_EC);  /* Duktape.modLoaded[resolved_id] = exports */
-+
-+	/* If user callback did not return source code, module loading
-+	 * is finished (user callback initialized exports table directly).
-+	 */
-+	if (!duk_is_string(ctx, 11)) {
-+		/* User callback did not return source code, so
-+		 * module loading is finished.
-+		 */
-+		duk_dup(ctx, 8);
-+		return 1;
-+	}
-+
-+	/* Finish the wrapped module source.  Force resolved module ID as the
-+	 * fileName so it gets set for functions defined within a module.  This
-+	 * also ensures loggers created within the module get the module ID as
-+	 * their default logger name.
-+	 */
-+	duk_push_string(ctx, "})");
-+	duk_concat(ctx, 3);
-+	duk_dup(ctx, 3);  /* resolved module ID for fileName */
-+	duk_eval_raw(ctx, NULL, 0, DUK_COMPILE_EVAL);
-+
-+	/* XXX: The module wrapper function is currently anonymous and is shown
-+	 * in stack traces.  It would be nice to force it to match the module
-+	 * name (perhaps just the cleaned up last term).  At the moment 'name'
-+	 * is write protected so we can't change it directly.  Note that we must
-+	 * not introduce an actual name binding into the function scope (which
-+	 * is usually the case with a named function) because it would affect
-+	 * the scope seen by the module and shadow accesses to globals of the
-+	 * same name.
-+	 */
-+
-+	/*
-+	 *  Call the wrapped module function.
-+	 */
-+
-+	/* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module mod_func ] */
-+	DUK_ASSERT_TOP(ctx, 11);
-+
-+	duk_dup(ctx, 8);  /* exports (this binding) */
-+	duk_dup(ctx, 7);  /* fresh require (argument) */
-+	duk_dup(ctx, 8);  /* exports (argument) */
-+	duk_dup(ctx, 9);  /* module (argument) */
-+
-+	/* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module mod_func exports fresh_require exports module ] */
-+	DUK_ASSERT_TOP(ctx, 15);
-+
-+	duk_call_method(ctx, 3 /*nargs*/);
-+
-+	/* [ requested_id require require.id resolved_id Duktape Duktape.modLoaded undefined fresh_require exports module result(ignored) ] */
-+	DUK_ASSERT_TOP(ctx, 11);
-+
-+	duk_pop_2(ctx);
-+	return 1;  /* return exports */
-+}
-+#else
-+DUK_INTERNAL duk_ret_t duk_bi_global_object_require(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+#endif  /* DUK_USE_COMMONJS_MODULES */
-+#line 1 "duk_bi_json.c"
-+/*
-+ *  JSON built-ins.
-+ *
-+ *  See doc/json.txt.
-+ *
-+ *  Codepoints are handled as duk_uint_fast32_t to ensure that the full
-+ *  unsigned 32-bit range is supported.  This matters to e.g. JX.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Local defines and forward declarations.
-+ */
-+
-+DUK_LOCAL_DECL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL duk_small_int_t duk__dec_peek(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL duk_small_int_t duk__dec_get(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL duk_small_int_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n);
-+DUK_LOCAL_DECL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx);
-+DUK_LOCAL_DECL void duk__dec_string(duk_json_dec_ctx *js_ctx);
-+#ifdef DUK_USE_JX
-+DUK_LOCAL_DECL void duk__dec_plain_string(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_pointer(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_buffer(duk_json_dec_ctx *js_ctx);
-+#endif
-+DUK_LOCAL_DECL void duk__dec_number(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_objarr_entry(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_objarr_exit(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_object(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_array(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_value(duk_json_dec_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__dec_reviver_walk(duk_json_dec_ctx *js_ctx);
-+
-+DUK_LOCAL_DECL void duk__emit_1(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch);
-+DUK_LOCAL_DECL void duk__emit_2(duk_json_enc_ctx *js_ctx, duk_uint_fast16_t packed_chars);
-+DUK_LOCAL_DECL void duk__emit_esc_auto(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp);
-+DUK_LOCAL_DECL void duk__emit_xutf8(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp);
-+DUK_LOCAL_DECL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h);
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+DUK_LOCAL_DECL void duk__emit_cstring(duk_json_enc_ctx *js_ctx, const char *p);
-+#endif
-+DUK_LOCAL_DECL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx);
-+DUK_LOCAL_DECL duk_bool_t duk__enc_key_quotes_needed(duk_hstring *h_key);
-+DUK_LOCAL_DECL void duk__enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_str);
-+DUK_LOCAL_DECL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top);
-+DUK_LOCAL_DECL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top);
-+DUK_LOCAL_DECL void duk__enc_object(duk_json_enc_ctx *js_ctx);
-+DUK_LOCAL_DECL void duk__enc_array(duk_json_enc_ctx *js_ctx);
-+DUK_LOCAL_DECL duk_bool_t duk__enc_value1(duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder);
-+DUK_LOCAL_DECL void duk__enc_value2(duk_json_enc_ctx *js_ctx);
-+DUK_LOCAL_DECL duk_bool_t duk__enc_allow_into_proplist(duk_tval *tv);
-+
-+/*
-+ *  Parsing implementation.
-+ *
-+ *  JSON lexer is now separate from duk_lexer.c because there are numerous
-+ *  small differences making it difficult to share the lexer.
-+ *
-+ *  The parser here works with raw bytes directly; this works because all
-+ *  JSON delimiters are ASCII characters.  Invalid xUTF-8 encoded values
-+ *  inside strings will be passed on without normalization; this is not a
-+ *  compliance concern because compliant inputs will always be valid
-+ *  CESU-8 encodings.
-+ */
-+
-+DUK_LOCAL void duk__dec_syntax_error(duk_json_dec_ctx *js_ctx) {
-+	/* Shared handler to minimize parser size.  Cause will be
-+	 * hidden, unfortunately, but we'll have an offset which
-+	 * is often quite enough.
-+	 */
-+	DUK_ERROR(js_ctx->thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_FMT_INVALID_JSON,
-+	         (long) (js_ctx->p - js_ctx->p_start));
-+}
-+
-+DUK_LOCAL void duk__dec_eat_white(duk_json_dec_ctx *js_ctx) {
-+	duk_small_uint_t t;
-+	for (;;) {
-+		if (js_ctx->p >= js_ctx->p_end) {
-+			break;
-+		}
-+		t = (*js_ctx->p);
-+		if (!(t == 0x20 || t == 0x0a || t == 0x0d || t == 0x09)) {
-+			break;
-+		}
-+		js_ctx->p++;
-+	}
-+}
-+
-+DUK_LOCAL duk_small_int_t duk__dec_peek(duk_json_dec_ctx *js_ctx) {
-+	if (js_ctx->p >= js_ctx->p_end) {
-+		return -1;
-+	} else {
-+		return (duk_small_int_t) (*js_ctx->p);
-+	}
-+}
-+
-+DUK_LOCAL duk_small_int_t duk__dec_get(duk_json_dec_ctx *js_ctx) {
-+	/* Multiple EOFs will now be supplied to the caller.  This could also be
-+	 * changed so that reading the second EOF would cause an error automatically.
-+	 */
-+	if (js_ctx->p >= js_ctx->p_end) {
-+		return -1;
-+	} else {
-+		return (duk_small_int_t) (*js_ctx->p++);
-+	}
-+}
-+
-+DUK_LOCAL duk_small_int_t duk__dec_get_nonwhite(duk_json_dec_ctx *js_ctx) {
-+	duk__dec_eat_white(js_ctx);
-+	return duk__dec_get(js_ctx);
-+}
-+
-+/* For JX, expressing the whole unsigned 32-bit range matters. */
-+DUK_LOCAL duk_uint_fast32_t duk__dec_decode_hex_escape(duk_json_dec_ctx *js_ctx, duk_small_uint_t n) {
-+	duk_small_uint_t i;
-+	duk_uint_fast32_t res = 0;
-+	duk_small_int_t x;
-+
-+	for (i = 0; i < n; i++) {
-+		/* XXX: share helper from lexer; duk_lexer.c / hexval(). */
-+
-+		x = duk__dec_get(js_ctx);
-+		DUK_ASSERT((x >= 0 && x <= 0xff) || (x == -1));
-+
-+		DUK_DDD(DUK_DDDPRINT("decode_hex_escape: i=%ld, n=%ld, res=%ld, x=%ld",
-+		                     (long) i, (long) n, (long) res, (long) x));
-+
-+		/* x == -1 will map to 0xff, dectab returns -1 which causes syntax_error */
-+		x = duk_hex_dectab[x & 0xff];
-+		if (DUK_LIKELY(x >= 0)) {
-+			res = (res * 16) + x;
-+		} else {
-+			/* catches EOF and invalid digits */
-+			goto syntax_error;
-+		}
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("final hex decoded value: %ld", (long) res));
-+	return res;
-+
-+ syntax_error:
-+	duk__dec_syntax_error(js_ctx);
-+	DUK_UNREACHABLE();
-+	return 0;
-+}
-+
-+DUK_LOCAL void duk__dec_req_stridx(duk_json_dec_ctx *js_ctx, duk_small_uint_t stridx) {
-+	duk_hstring *h;
-+	duk_uint8_t *p;
-+	duk_uint8_t *p_end;
-+	duk_small_int_t x;
-+
-+	/* First character has already been eaten and checked by the caller. */
-+
-+	DUK_ASSERT_DISABLE(stridx >= 0);  /* unsigned */
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+	h = DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx);
-+	DUK_ASSERT(h != NULL);
-+
-+	p = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h);
-+	p_end = ((duk_uint8_t *) DUK_HSTRING_GET_DATA(h)) +
-+	        DUK_HSTRING_GET_BYTELEN(h);
-+
-+	DUK_ASSERT(*(js_ctx->p - 1) == *p);  /* first character has been matched */
-+	p++;  /* first char */
-+
-+	while (p < p_end) {
-+		x = duk__dec_get(js_ctx);
-+		if ((duk_small_int_t) (*p) != x) {
-+			/* catches EOF */
-+			goto syntax_error;
-+		}
-+		p++;
-+	}
-+
-+	return;
-+
-+ syntax_error:
-+	duk__dec_syntax_error(js_ctx);
-+	DUK_UNREACHABLE();
-+}
-+
-+DUK_LOCAL void duk__dec_string(duk_json_dec_ctx *js_ctx) {
-+	duk_hthread *thr = js_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hbuffer_dynamic *h_buf;
-+	duk_small_int_t x;
-+	duk_uint_fast32_t cp;
-+
-+	/* '"' was eaten by caller */
-+
-+	/* Note that we currently parse -bytes-, not codepoints.
-+	 * All non-ASCII extended UTF-8 will encode to bytes >= 0x80,
-+	 * so they'll simply pass through (valid UTF-8 or not).
-+	 */
-+
-+	duk_push_dynamic_buffer(ctx, 0);
-+	h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(h_buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf));
-+
-+	for (;;) {
-+		x = duk__dec_get(js_ctx);
-+		if (x == DUK_ASC_DOUBLEQUOTE) {
-+			break;
-+		} else if (x == DUK_ASC_BACKSLASH) {
-+			/* EOF (-1) will be cast to an unsigned value first
-+			 * and then re-cast for the switch.  In any case, it
-+			 * will match the default case (syntax error).
-+			 */
-+			cp = (duk_uint_fast32_t) duk__dec_get(js_ctx);
-+			switch ((int) cp) {
-+			case DUK_ASC_BACKSLASH: break;
-+			case DUK_ASC_DOUBLEQUOTE: break;
-+			case DUK_ASC_SLASH: break;
-+			case DUK_ASC_LC_T: cp = 0x09; break;
-+			case DUK_ASC_LC_N: cp = 0x0a; break;
-+			case DUK_ASC_LC_R: cp = 0x0d; break;
-+			case DUK_ASC_LC_F: cp = 0x0c; break;
-+			case DUK_ASC_LC_B: cp = 0x08; break;
-+			case DUK_ASC_LC_U: {
-+				cp = duk__dec_decode_hex_escape(js_ctx, 4);
-+				break;
-+			}
-+#ifdef DUK_USE_JX
-+			case DUK_ASC_UC_U: {
-+				if (js_ctx->flag_ext_custom) {
-+					cp = duk__dec_decode_hex_escape(js_ctx, 8);
-+				} else {
-+					goto syntax_error;
-+				}
-+				break;
-+			}
-+			case DUK_ASC_LC_X: {
-+				if (js_ctx->flag_ext_custom) {
-+					cp = duk__dec_decode_hex_escape(js_ctx, 2);
-+				} else {
-+					goto syntax_error;
-+				}
-+				break;
-+			}
-+#endif  /* DUK_USE_JX */
-+			default:
-+				/* catches EOF (-1) */
-+				goto syntax_error;
-+			}
-+			duk_hbuffer_append_xutf8(thr, h_buf, (duk_uint32_t) cp);
-+		} else if (x < 0x20) {
-+			/* catches EOF (-1) */
-+			goto syntax_error;
-+		} else {
-+			duk_hbuffer_append_byte(thr, h_buf, (duk_uint8_t) x);
-+		}
-+	}
-+
-+	duk_to_string(ctx, -1);
-+
-+	/* [ ... str ] */
-+
-+	return;
-+
-+ syntax_error:
-+	duk__dec_syntax_error(js_ctx);
-+	DUK_UNREACHABLE();
-+}
-+
-+#ifdef DUK_USE_JX
-+/* Decode a plain string consisting entirely of identifier characters.
-+ * Used to parse plain keys (e.g. "foo: 123").
-+ */
-+DUK_LOCAL void duk__dec_plain_string(duk_json_dec_ctx *js_ctx) {
-+	duk_hthread *thr = js_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	const duk_uint8_t *p;
-+	duk_small_int_t x;
-+
-+	/* Caller has already eaten the first char so backtrack one byte. */
-+
-+	js_ctx->p--;  /* safe */
-+	p = js_ctx->p;
-+
-+	/* Here again we parse bytes, and non-ASCII UTF-8 will cause end of
-+	 * parsing (which is correct except if there are non-shortest encodings).
-+	 * There is also no need to check explicitly for end of input buffer as
-+	 * the input is NUL padded and NUL will exit the parsing loop.
-+	 *
-+	 * Because no unescaping takes place, we can just scan to the end of the
-+	 * plain string and intern from the input buffer.
-+	 */
-+
-+	for (;;) {
-+		x = *p;
-+
-+		/* There is no need to check the first character specially here
-+		 * (i.e. reject digits): the caller only accepts valid initial
-+		 * characters and won't call us if the first character is a digit.
-+		 * This also ensures that the plain string won't be empty.
-+		 */
-+
-+		if (!duk_unicode_is_identifier_part((duk_codepoint_t) x)) {
-+			break;
-+		}
-+		p++;
-+	}
-+
-+	duk_push_lstring(ctx, (const char *) js_ctx->p, (duk_size_t) (p - js_ctx->p));
-+	js_ctx->p = p;
-+
-+	/* [ ... str ] */
-+}
-+#endif  /* DUK_USE_JX */
-+
-+#ifdef DUK_USE_JX
-+DUK_LOCAL void duk__dec_pointer(duk_json_dec_ctx *js_ctx) {
-+	duk_hthread *thr = js_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	const duk_uint8_t *p;
-+	duk_small_int_t x;
-+	void *voidptr;
-+
-+	/* Caller has already eaten the first character ('(') which we don't need. */
-+
-+	p = js_ctx->p;
-+
-+	for (;;) {
-+		x = *p;
-+
-+		/* Assume that the native representation never contains a closing
-+		 * parenthesis.
-+		 */
-+
-+		if (x == DUK_ASC_RPAREN) {
-+			break;
-+		} else if (x <= 0) {
-+			/* NUL term or -1 (EOF), NUL check would suffice */
-+			goto syntax_error;
-+		}
-+		p++;
-+	}
-+
-+	/* There is no need to NUL delimit the sscanf() call: trailing garbage is
-+	 * ignored and there is always a NUL terminator which will force an error
-+	 * if no error is encountered before it.  It's possible that the scan
-+	 * would scan further than between [js_ctx->p,p[ though and we'd advance
-+	 * by less than the scanned value.
-+	 *
-+	 * Because pointers are platform specific, a failure to scan a pointer
-+	 * results in a null pointer which is a better placeholder than a missing
-+	 * value or an error.
-+	 */
-+
-+	voidptr = NULL;
-+	(void) DUK_SSCANF((const char *) js_ctx->p, DUK_STR_FMT_PTR, &voidptr);
-+	duk_push_pointer(ctx, voidptr);
-+	js_ctx->p = p + 1;  /* skip ')' */
-+
-+	/* [ ... ptr ] */
-+
-+	return;
-+
-+ syntax_error:
-+	duk__dec_syntax_error(js_ctx);
-+	DUK_UNREACHABLE();
-+}
-+#endif  /* DUK_USE_JX */
-+
-+#ifdef DUK_USE_JX
-+DUK_LOCAL void duk__dec_buffer(duk_json_dec_ctx *js_ctx) {
-+	duk_hthread *thr = js_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	const duk_uint8_t *p;
-+	duk_small_int_t x;
-+
-+	/* Caller has already eaten the first character ('|') which we don't need. */
-+
-+	p = js_ctx->p;
-+
-+	for (;;) {
-+		x = *p;
-+
-+		/* This loop intentionally does not ensure characters are valid
-+		 * ([0-9a-fA-F]) because the hex decode call below will do that.
-+		 */
-+		if (x == DUK_ASC_PIPE) {
-+			break;
-+		} else if (x <= 0) {
-+			/* NUL term or -1 (EOF), NUL check would suffice */
-+			goto syntax_error;
-+		}
-+		p++;
-+	}
-+
-+	duk_push_lstring(ctx, (const char *) js_ctx->p, (duk_size_t) (p - js_ctx->p));
-+	duk_hex_decode(ctx, -1);
-+	js_ctx->p = p + 1;  /* skip '|' */
-+
-+	/* [ ... buf ] */
-+
-+	return;
-+
-+ syntax_error:
-+	duk__dec_syntax_error(js_ctx);
-+	DUK_UNREACHABLE();
-+}
-+#endif  /* DUK_USE_JX */
-+
-+/* Parse a number, other than NaN or +/- Infinity */
-+DUK_LOCAL void duk__dec_number(duk_json_dec_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	const duk_uint8_t *p_start;
-+	duk_small_int_t x;
-+	duk_small_uint_t s2n_flags;
-+
-+	DUK_DDD(DUK_DDDPRINT("parse_number"));
-+
-+	/* Caller has already eaten the first character so backtrack one
-+	 * byte.  This is correct because the first character is either
-+	 * '-' or a digit (i.e. an ASCII character).
-+	 */
-+
-+	js_ctx->p--;  /* safe */
-+	p_start = js_ctx->p;
-+
-+	/* First pass parse is very lenient (e.g. allows '1.2.3') and extracts a
-+	 * string for strict number parsing.
-+	 */
-+
-+	for (;;) {
-+		x = duk__dec_peek(js_ctx);
-+
-+		DUK_DDD(DUK_DDDPRINT("parse_number: p_start=%p, p=%p, p_end=%p, x=%ld",
-+		                     (void *) p_start, (void *) js_ctx->p,
-+		                     (void *) js_ctx->p_end, (long) x));
-+
-+		if (!((x >= DUK_ASC_0 && x <= DUK_ASC_9) ||
-+		      (x == DUK_ASC_PERIOD || x == DUK_ASC_LC_E ||
-+		       x == DUK_ASC_UC_E || x == DUK_ASC_MINUS || x == DUK_ASC_PLUS))) {
-+			/* Plus sign must be accepted for positive exponents
-+			 * (e.g. '1.5e+2').
-+			 */
-+			break;
-+		}
-+
-+		js_ctx->p++;  /* safe, because matched char */
-+	}
-+
-+	DUK_ASSERT(js_ctx->p > p_start);
-+	duk_push_lstring(ctx, (const char *) p_start, (duk_size_t) (js_ctx->p - p_start));
-+
-+	s2n_flags = DUK_S2N_FLAG_ALLOW_EXP |
-+	            DUK_S2N_FLAG_ALLOW_MINUS |  /* but don't allow leading plus */
-+	            DUK_S2N_FLAG_ALLOW_FRAC;
-+
-+	DUK_DDD(DUK_DDDPRINT("parse_number: string before parsing: %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+	duk_numconv_parse(ctx, 10 /*radix*/, s2n_flags);
-+	if (duk_is_nan(ctx, -1)) {
-+		duk__dec_syntax_error(js_ctx);
-+	}
-+	DUK_ASSERT(duk_is_number(ctx, -1));
-+	DUK_DDD(DUK_DDDPRINT("parse_number: final number: %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/* [ ... num ] */
-+}
-+
-+DUK_LOCAL void duk__dec_objarr_entry(duk_json_dec_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_require_stack(ctx, DUK_JSON_DEC_REQSTACK);
-+
-+	/* c recursion check */
-+
-+	DUK_ASSERT(js_ctx->recursion_depth >= 0);
-+	DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
-+	if (js_ctx->recursion_depth >= js_ctx->recursion_limit) {
-+		DUK_ERROR((duk_hthread *) ctx, DUK_ERR_RANGE_ERROR, DUK_STR_JSONDEC_RECLIMIT);
-+	}
-+	js_ctx->recursion_depth++;
-+}
-+
-+DUK_LOCAL void duk__dec_objarr_exit(duk_json_dec_ctx *js_ctx) {
-+	/* c recursion check */
-+
-+	DUK_ASSERT(js_ctx->recursion_depth > 0);
-+	DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
-+	js_ctx->recursion_depth--;
-+}
-+
-+DUK_LOCAL void duk__dec_object(duk_json_dec_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_int_t key_count;  /* XXX: a "first" flag would suffice */
-+	duk_small_int_t x;
-+
-+	DUK_DDD(DUK_DDDPRINT("parse_object"));
-+
-+	duk__dec_objarr_entry(js_ctx);
-+
-+	duk_push_object(ctx);
-+
-+	/* Initial '{' has been checked and eaten by caller. */
-+
-+	key_count = 0;
-+	for (;;) {
-+		x = duk__dec_get_nonwhite(js_ctx);
-+
-+		DUK_DDD(DUK_DDDPRINT("parse_object: obj=%!T, x=%ld, key_count=%ld",
-+		                     (duk_tval *) duk_get_tval(ctx, -1),
-+		                     (long) x, (long) key_count));
-+
-+		/* handle comma and closing brace */
-+
-+		if (x == DUK_ASC_COMMA && key_count > 0) {
-+			/* accept comma, expect new value */
-+			x = duk__dec_get_nonwhite(js_ctx);
-+		} else if (x == DUK_ASC_RCURLY) {
-+			/* eat closing brace */
-+			break;
-+		} else if (key_count == 0) {
-+			/* accept anything, expect first value (EOF will be
-+			 * caught by key parsing below.
-+			 */
-+			;
-+		} else {
-+			/* catches EOF (and initial comma) */
-+			goto syntax_error;
-+		}
-+
-+		/* parse key and value */
-+
-+		if (x == DUK_ASC_DOUBLEQUOTE) {
-+			duk__dec_string(js_ctx);
-+#ifdef DUK_USE_JX
-+		} else if (js_ctx->flag_ext_custom &&
-+		           duk_unicode_is_identifier_start((duk_codepoint_t) x)) {
-+			duk__dec_plain_string(js_ctx);
-+#endif
-+		} else {
-+			goto syntax_error;
-+		}
-+
-+		/* [ ... obj key ] */
-+
-+		x = duk__dec_get_nonwhite(js_ctx);
-+		if (x != DUK_ASC_COLON) {
-+			goto syntax_error;
-+		}
-+
-+		duk__dec_value(js_ctx);
-+
-+		/* [ ... obj key val ] */
-+
-+		duk_xdef_prop_wec(ctx, -3);
-+
-+		/* [ ... obj ] */
-+
-+		key_count++;
-+	}
-+
-+	/* [ ... obj ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("parse_object: final object is %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	duk__dec_objarr_exit(js_ctx);
-+	return;
-+
-+ syntax_error:
-+	duk__dec_syntax_error(js_ctx);
-+	DUK_UNREACHABLE();
-+}
-+
-+DUK_LOCAL void duk__dec_array(duk_json_dec_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_uarridx_t arr_idx;
-+	duk_small_int_t x;
-+
-+	DUK_DDD(DUK_DDDPRINT("parse_array"));
-+
-+	duk__dec_objarr_entry(js_ctx);
-+
-+	duk_push_array(ctx);
-+
-+	/* Initial '[' has been checked and eaten by caller. */
-+
-+	arr_idx = 0;
-+	for (;;) {
-+		x = duk__dec_get_nonwhite(js_ctx);
-+
-+		DUK_DDD(DUK_DDDPRINT("parse_array: arr=%!T, x=%ld, arr_idx=%ld",
-+		                     (duk_tval *) duk_get_tval(ctx, -1),
-+		                     (long) x, (long) arr_idx));
-+
-+		/* handle comma and closing bracket */
-+
-+		if ((x == DUK_ASC_COMMA) && (arr_idx != 0)) {
-+			/* accept comma, expect new value */
-+			;
-+		} else if (x == DUK_ASC_RBRACKET) {
-+			/* eat closing bracket */
-+			break;
-+		} else if (arr_idx == 0) {
-+			/* accept anything, expect first value (EOF will be
-+			 * caught by duk__dec_value() below.
-+			 */
-+			js_ctx->p--;  /* backtrack (safe) */
-+		} else {
-+			/* catches EOF (and initial comma) */
-+			goto syntax_error;
-+		}
-+
-+		/* parse value */
-+
-+		duk__dec_value(js_ctx);
-+
-+		/* [ ... arr val ] */
-+
-+		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-+		arr_idx++;
-+	}
-+
-+	/* Must set 'length' explicitly when using duk_xdef_prop_xxx() to
-+	 * set the values.
-+	 */
-+
-+	duk_set_length(ctx, -1, arr_idx);
-+
-+	/* [ ... arr ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("parse_array: final array is %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	duk__dec_objarr_exit(js_ctx);
-+	return;
-+
-+ syntax_error:
-+	duk__dec_syntax_error(js_ctx);
-+	DUK_UNREACHABLE();
-+}
-+
-+DUK_LOCAL void duk__dec_value(duk_json_dec_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_small_int_t x;
-+
-+	x = duk__dec_get_nonwhite(js_ctx);
-+
-+	DUK_DDD(DUK_DDDPRINT("parse_value: initial x=%ld", (long) x));
-+
-+	/* Note: duk__dec_req_stridx() backtracks one char */
-+
-+	if (x == DUK_ASC_DOUBLEQUOTE) {
-+		duk__dec_string(js_ctx);
-+	} else if ((x >= DUK_ASC_0 && x <= DUK_ASC_9) || (x == DUK_ASC_MINUS)) {
-+#ifdef DUK_USE_JX
-+		if (js_ctx->flag_ext_custom && x == DUK_ASC_MINUS && duk__dec_peek(js_ctx) == DUK_ASC_UC_I) {
-+			duk__dec_req_stridx(js_ctx, DUK_STRIDX_MINUS_INFINITY);  /* "-Infinity", '-' has been eaten */
-+			duk_push_number(ctx, -DUK_DOUBLE_INFINITY);
-+		} else {
-+#else
-+		{  /* unconditional block */
-+#endif
-+			/* We already ate 'x', so duk__dec_number() will back up one byte. */
-+			duk__dec_number(js_ctx);
-+		}
-+	} else if (x == DUK_ASC_LC_T) {
-+		duk__dec_req_stridx(js_ctx, DUK_STRIDX_TRUE);
-+		duk_push_true(ctx);
-+	} else if (x == DUK_ASC_LC_F) {
-+		duk__dec_req_stridx(js_ctx, DUK_STRIDX_FALSE);
-+		duk_push_false(ctx);
-+	} else if (x == DUK_ASC_LC_N) {
-+		duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_NULL);
-+		duk_push_null(ctx);
-+#ifdef DUK_USE_JX
-+	} else if (js_ctx->flag_ext_custom && x == DUK_ASC_LC_U) {
-+		duk__dec_req_stridx(js_ctx, DUK_STRIDX_LC_UNDEFINED);
-+		duk_push_undefined(ctx);
-+	} else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_N) {
-+		duk__dec_req_stridx(js_ctx, DUK_STRIDX_NAN);
-+		duk_push_nan(ctx);
-+	} else if (js_ctx->flag_ext_custom && x == DUK_ASC_UC_I) {
-+		duk__dec_req_stridx(js_ctx, DUK_STRIDX_INFINITY);
-+		duk_push_number(ctx, DUK_DOUBLE_INFINITY);
-+	} else if (js_ctx->flag_ext_custom && x == DUK_ASC_LPAREN) {
-+		duk__dec_pointer(js_ctx);
-+	} else if (js_ctx->flag_ext_custom && x == DUK_ASC_PIPE) {
-+		duk__dec_buffer(js_ctx);
-+#endif
-+	} else if (x == DUK_ASC_LCURLY) {
-+		duk__dec_object(js_ctx);
-+	} else if (x == DUK_ASC_LBRACKET) {
-+		duk__dec_array(js_ctx);
-+	} else {
-+		/* catches EOF */
-+		goto syntax_error;
-+	}
-+
-+	duk__dec_eat_white(js_ctx);
-+
-+	/* [ ... val ] */
-+	return;
-+
-+ syntax_error:
-+	duk__dec_syntax_error(js_ctx);
-+	DUK_UNREACHABLE();
-+}
-+
-+/* Recursive value reviver, implements the Walk() algorithm.  No C recursion
-+ * check is done here because the initial parsing step will already ensure
-+ * there is a reasonable limit on C recursion depth and hence object depth.
-+ */
-+DUK_LOCAL void duk__dec_reviver_walk(duk_json_dec_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_hobject *h;
-+	duk_uarridx_t i, arr_len;
-+
-+	DUK_DDD(DUK_DDDPRINT("walk: top=%ld, holder=%!T, name=%!T",
-+	                     (long) duk_get_top(ctx),
-+	                     (duk_tval *) duk_get_tval(ctx, -2),
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	duk_dup_top(ctx);
-+	duk_get_prop(ctx, -3);  /* -> [ ... holder name val ] */
-+
-+	h = duk_get_hobject(ctx, -1);
-+	if (h != NULL) {
-+		if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) {
-+			arr_len = (duk_uarridx_t) duk_get_length(ctx, -1);
-+			for (i = 0; i < arr_len; i++) {
-+				/* [ ... holder name val ] */
-+
-+				DUK_DDD(DUK_DDDPRINT("walk: array, top=%ld, i=%ld, arr_len=%ld, holder=%!T, name=%!T, val=%!T",
-+				                     (long) duk_get_top(ctx), (long) i, (long) arr_len,
-+				                     (duk_tval *) duk_get_tval(ctx, -3), (duk_tval *) duk_get_tval(ctx, -2),
-+				                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+				/* XXX: push_uint_string / push_u32_string */
-+				duk_dup_top(ctx);
-+				duk_push_uint(ctx, (duk_uint_t) i);
-+				duk_to_string(ctx, -1);  /* -> [ ... holder name val val ToString(i) ] */
-+				duk__dec_reviver_walk(js_ctx);  /* -> [ ... holder name val new_elem ] */
-+
-+				if (duk_is_undefined(ctx, -1)) {
-+					duk_pop(ctx);
-+					duk_del_prop_index(ctx, -1, i);
-+				} else {
-+					/* XXX: duk_xdef_prop_index_wec() would be more appropriate
-+					 * here but it currently makes some assumptions that might
-+					 * not hold (e.g. that previous property is not an accessor).
-+					 */
-+					duk_put_prop_index(ctx, -2, i);
-+				}
-+			}
-+		} else {
-+			/* [ ... holder name val ] */
-+			duk_enum(ctx, -1, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/);
-+			while (duk_next(ctx, -1 /*enum_index*/, 0 /*get_value*/)) {
-+				DUK_DDD(DUK_DDDPRINT("walk: object, top=%ld, holder=%!T, name=%!T, val=%!T, enum=%!iT, obj_key=%!T",
-+				                     (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -5),
-+				                     (duk_tval *) duk_get_tval(ctx, -4), (duk_tval *) duk_get_tval(ctx, -3),
-+				                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+				/* [ ... holder name val enum obj_key ] */
-+				duk_dup(ctx, -3);
-+				duk_dup(ctx, -2);
-+
-+				/* [ ... holder name val enum obj_key val obj_key ] */
-+				duk__dec_reviver_walk(js_ctx);
-+
-+				/* [ ... holder name val enum obj_key new_elem ] */
-+				if (duk_is_undefined(ctx, -1)) {
-+					duk_pop(ctx);
-+					duk_del_prop(ctx, -3);
-+				} else {
-+					/* XXX: duk_xdef_prop_index_wec() would be more appropriate
-+					 * here but it currently makes some assumptions that might
-+					 * not hold (e.g. that previous property is not an accessor).
-+					 *
-+					 * Using duk_put_prop() works incorrectly with '__proto__'
-+					 * if the own property with that name has been deleted.  This
-+					 * does not happen normally, but a clever reviver can trigger
-+					 * that, see complex reviver case in: test-bug-json-parse-__proto__.js.
-+					 */
-+					duk_put_prop(ctx, -4);
-+				}
-+			}
-+			duk_pop(ctx);  /* pop enum */
-+		}
-+	}
-+
-+	/* [ ... holder name val ] */
-+
-+	duk_dup(ctx, js_ctx->idx_reviver);
-+	duk_insert(ctx, -4);  /* -> [ ... reviver holder name val ] */
-+	duk_call_method(ctx, 2);  /* -> [ ... res ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("walk: top=%ld, result=%!T",
-+	                     (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, -1)));
-+}
-+
-+/*
-+ *  Stringify implementation.
-+ */
-+
-+#define DUK__EMIT_1(js_ctx,ch)          duk__emit_1((js_ctx), (duk_uint_fast8_t) (ch))
-+#define DUK__EMIT_2(js_ctx,ch1,ch2)     duk__emit_2((js_ctx), (((duk_uint_fast16_t)(ch1)) << 8) + (duk_uint_fast16_t)(ch2))
-+#define DUK__EMIT_ESC_AUTO(js_ctx,cp)   duk__emit_esc_auto((js_ctx), (cp))
-+#define DUK__EMIT_XUTF8(js_ctx,cp)      duk__emit_xutf8((js_ctx), (cp))
-+#define DUK__EMIT_HSTR(js_ctx,h)        duk__emit_hstring((js_ctx), (h))
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+#define DUK__EMIT_CSTR(js_ctx,p)        duk__emit_cstring((js_ctx), (p))
-+#endif
-+#define DUK__EMIT_STRIDX(js_ctx,i)      duk__emit_stridx((js_ctx), (i))
-+
-+DUK_LOCAL void duk__emit_1(duk_json_enc_ctx *js_ctx, duk_uint_fast8_t ch) {
-+	duk_hbuffer_append_byte(js_ctx->thr, js_ctx->h_buf, (duk_uint8_t) ch);
-+}
-+
-+DUK_LOCAL void duk__emit_2(duk_json_enc_ctx *js_ctx, duk_uint_fast16_t packed_chars) {
-+	duk_uint8_t buf[2];
-+	buf[0] = (duk_uint8_t) (packed_chars >> 8);
-+	buf[1] = (duk_uint8_t) (packed_chars & 0xff);
-+	duk_hbuffer_append_bytes(js_ctx->thr, js_ctx->h_buf, (duk_uint8_t *) buf, 2);
-+}
-+
-+#define DUK__MKESC(nybbles,esc1,esc2)  \
-+	(((duk_uint_fast32_t) (nybbles)) << 16) | \
-+	(((duk_uint_fast32_t) (esc1)) << 8) | \
-+	((duk_uint_fast32_t) (esc2))
-+
-+DUK_LOCAL void duk__emit_esc_auto(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp) {
-+	duk_uint8_t buf[2];
-+	duk_uint_fast32_t tmp;
-+	duk_small_uint_t dig;
-+
-+	/* Select appropriate escape format automatically, and set 'tmp' to a
-+	 * value encoding both the escape format character and the nybble count:
-+	 *
-+	 *   (nybble_count << 16) | (escape_char1) | (escape_char2)
-+	 */
-+
-+#ifdef DUK_USE_JX
-+	if (DUK_LIKELY(cp < 0x100UL)) {
-+		if (DUK_UNLIKELY(js_ctx->flag_ext_custom)) {
-+			tmp = DUK__MKESC(2, DUK_ASC_BACKSLASH, DUK_ASC_LC_X);
-+		} else {
-+			tmp = DUK__MKESC(4, DUK_ASC_BACKSLASH, DUK_ASC_LC_U);
-+		}
-+	} else
-+#endif
-+	if (DUK_LIKELY(cp < 0x10000UL)) {
-+		tmp = DUK__MKESC(4, DUK_ASC_BACKSLASH, DUK_ASC_LC_U);
-+	} else {
-+#ifdef DUK_USE_JX
-+		if (DUK_LIKELY(js_ctx->flag_ext_custom)) {
-+			tmp = DUK__MKESC(8, DUK_ASC_BACKSLASH, DUK_ASC_UC_U);
-+		} else
-+#endif
-+		{
-+			/* In compatible mode and standard JSON mode, output
-+			 * something useful for non-BMP characters.  This won't
-+			 * roundtrip but will still be more or less readable and
-+			 * more useful than an error.
-+			 */
-+			tmp = DUK__MKESC(8, DUK_ASC_UC_U, DUK_ASC_PLUS);
-+		}
-+	}
-+
-+	buf[0] = (duk_uint8_t) ((tmp >> 8) & 0xff);
-+	buf[1] = (duk_uint8_t) (tmp & 0xff);
-+	duk_hbuffer_append_bytes(js_ctx->thr, js_ctx->h_buf, buf, 2);
-+
-+	tmp = tmp >> 16;
-+	while (tmp > 0) {
-+		tmp--;
-+		dig = (duk_small_uint_t) ((cp >> (4 * tmp)) & 0x0f);
-+		duk_hbuffer_append_byte(js_ctx->thr, js_ctx->h_buf, duk_lc_digits[dig]);
-+	}
-+}
-+
-+DUK_LOCAL void duk__emit_xutf8(duk_json_enc_ctx *js_ctx, duk_uint_fast32_t cp) {
-+	(void) duk_hbuffer_append_xutf8(js_ctx->thr, js_ctx->h_buf, cp);
-+}
-+
-+DUK_LOCAL void duk__emit_hstring(duk_json_enc_ctx *js_ctx, duk_hstring *h) {
-+	DUK_ASSERT(h != NULL);
-+	duk_hbuffer_append_bytes(js_ctx->thr,
-+	                         js_ctx->h_buf,
-+	                         (duk_uint8_t *) DUK_HSTRING_GET_DATA(h),
-+	                         (duk_size_t) DUK_HSTRING_GET_BYTELEN(h));
-+}
-+
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+DUK_LOCAL void duk__emit_cstring(duk_json_enc_ctx *js_ctx, const char *p) {
-+	DUK_ASSERT(p != NULL);
-+	(void) duk_hbuffer_append_cstring(js_ctx->thr, js_ctx->h_buf, p);
-+}
-+#endif
-+
-+DUK_LOCAL void duk__emit_stridx(duk_json_enc_ctx *js_ctx, duk_small_uint_t stridx) {
-+	DUK_ASSERT_DISABLE(stridx >= 0);  /* unsigned */
-+	DUK_ASSERT(stridx < DUK_HEAP_NUM_STRINGS);
-+	duk__emit_hstring(js_ctx, DUK_HTHREAD_GET_STRING(js_ctx->thr, stridx));
-+}
-+
-+/* Check whether key quotes would be needed (custom encoding). */
-+DUK_LOCAL duk_bool_t duk__enc_key_quotes_needed(duk_hstring *h_key) {
-+	const duk_uint8_t *p, *p_start, *p_end;
-+	duk_small_uint_t ch;
-+
-+	DUK_ASSERT(h_key != NULL);
-+	p_start = DUK_HSTRING_GET_DATA(h_key);
-+	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_key);
-+	p = p_start;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__enc_key_quotes_needed: h_key=%!O, p_start=%p, p_end=%p, p=%p",
-+	                     (duk_heaphdr *) h_key, (void *) p_start, (void *) p_end, (void *) p));
-+
-+	/* Since we only accept ASCII characters, there is no need for
-+	 * actual decoding.  A non-ASCII character will be >= 0x80 which
-+	 * causes a false return value immediately.
-+	 */
-+
-+	if (p == p_end) {
-+		/* Zero length string is not accepted without quotes */
-+		return 1;
-+	}
-+
-+	while (p < p_end) {
-+		ch = (duk_small_uint_t) (*p);
-+
-+		/* Accept ASCII IdentifierStart and IdentifierPart if not first char.
-+		 * Function selection is a bit uncommon.
-+		 */
-+		if ((p > p_start ? duk_unicode_is_identifier_part :
-+		                   duk_unicode_is_identifier_start) ((duk_codepoint_t) ch)) {
-+			p++;
-+			continue;
-+		}
-+
-+		/* all non-ASCII characters also come here (first byte >= 0x80) */
-+		return 1;
-+	}
-+
-+	return 0;
-+}
-+
-+/* The Quote(value) operation: quote a string.
-+ *
-+ * Stack policy: [ ] -> [ ].
-+ */
-+
-+DUK_LOCAL duk_uint8_t duk__quote_esc[14] = {
-+	DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL,
-+	DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL, DUK_ASC_NUL,
-+	DUK_ASC_LC_B, DUK_ASC_LC_T, DUK_ASC_LC_N, DUK_ASC_NUL,
-+	DUK_ASC_LC_F, DUK_ASC_LC_R
-+};
-+
-+DUK_LOCAL void duk__enc_quote_string(duk_json_enc_ctx *js_ctx, duk_hstring *h_str) {
-+	duk_hthread *thr = js_ctx->thr;
-+	const duk_uint8_t *p, *p_start, *p_end, *p_tmp;
-+	duk_ucodepoint_t cp;  /* typed for duk_unicode_decode_xutf8() */
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__enc_quote_string: h_str=%!O", (duk_heaphdr *) h_str));
-+
-+	DUK_ASSERT(h_str != NULL);
-+	p_start = DUK_HSTRING_GET_DATA(h_str);
-+	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_str);
-+	p = p_start;
-+
-+	DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE);
-+
-+	while (p < p_end) {
-+		cp = *p;
-+
-+		if (DUK_LIKELY(cp <= 0x7f)) {
-+			/* ascii fast path: avoid decoding utf-8 */
-+			p++;
-+			if (cp == 0x22 || cp == 0x5c) {
-+				/* double quote or backslash */
-+				DUK__EMIT_2(js_ctx, DUK_ASC_BACKSLASH, cp);
-+			} else if (cp < 0x20) {
-+				duk_uint_fast8_t esc_char;
-+
-+				/* This approach is a bit shorter than a straight
-+				 * if-else-ladder and also a bit faster.
-+				 */
-+				if (cp < (sizeof(duk__quote_esc) / sizeof(duk_uint8_t)) &&
-+				    (esc_char = duk__quote_esc[cp]) != 0) {
-+					DUK__EMIT_2(js_ctx, DUK_ASC_BACKSLASH, esc_char);
-+				} else {
-+					DUK__EMIT_ESC_AUTO(js_ctx, cp);
-+				}
-+			} else if (cp == 0x7f && js_ctx->flag_ascii_only) {
-+				DUK__EMIT_ESC_AUTO(js_ctx, cp);
-+			} else {
-+				/* any other printable -> as is */
-+				DUK__EMIT_1(js_ctx, cp);
-+			}
-+		} else {
-+			/* slow path decode */
-+
-+			/* If XUTF-8 decoding fails, treat the offending byte as a codepoint directly
-+			 * and go forward one byte.  This is of course very lossy, but allows some kind
-+			 * of output to be produced even for internal strings which don't conform to
-+			 * XUTF-8.  All standard Ecmascript strings are always CESU-8, so this behavior
-+			 * does not violate the Ecmascript specification.  The behavior is applied to
-+			 * all modes, including Ecmascript standard JSON.  Because the current XUTF-8
-+			 * decoding is not very strict, this behavior only really affects initial bytes
-+			 * and truncated codepoints.
-+			 *
-+			 * XXX: another alternative would be to scan forwards to start of next codepoint
-+			 * (or end of input) and emit just one replacement codepoint.
-+			 */
-+
-+			p_tmp = p;
-+			if (!duk_unicode_decode_xutf8(thr, &p, p_start, p_end, &cp)) {
-+				/* Decode failed. */
-+				cp = *p_tmp;
-+				p = p_tmp + 1;
-+			}
-+
-+#ifdef DUK_USE_NONSTD_JSON_ESC_U2028_U2029
-+			if (js_ctx->flag_ascii_only || cp == 0x2028 || cp == 0x2029) {
-+#else
-+			if (js_ctx->flag_ascii_only) {
-+#endif
-+				DUK__EMIT_ESC_AUTO(js_ctx, cp);
-+			} else {
-+				/* as is */
-+				DUK__EMIT_XUTF8(js_ctx, cp);
-+			}
-+		}
-+	}
-+
-+	DUK__EMIT_1(js_ctx, DUK_ASC_DOUBLEQUOTE);
-+}
-+
-+/* Shared entry handling for object/array serialization: indent/stepback,
-+ * loop detection.
-+ */
-+DUK_LOCAL void duk__enc_objarr_entry(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_hobject *h_target;
-+
-+	*entry_top = duk_get_top(ctx);
-+
-+	duk_require_stack(ctx, DUK_JSON_ENC_REQSTACK);
-+
-+	/* loop check */
-+
-+	h_target = duk_get_hobject(ctx, -1);  /* object or array */
-+	DUK_ASSERT(h_target != NULL);
-+	duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target);
-+
-+	duk_dup_top(ctx);  /* -> [ ... voidp voidp ] */
-+	if (duk_has_prop(ctx, js_ctx->idx_loop)) {
-+		DUK_ERROR((duk_hthread *) ctx, DUK_ERR_TYPE_ERROR, DUK_STR_CYCLIC_INPUT);
-+	}
-+	duk_push_true(ctx);  /* -> [ ... voidp true ] */
-+	duk_put_prop(ctx, js_ctx->idx_loop);  /* -> [ ... ] */
-+
-+	/* c recursion check */
-+
-+	DUK_ASSERT(js_ctx->recursion_depth >= 0);
-+	DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
-+	if (js_ctx->recursion_depth >= js_ctx->recursion_limit) {
-+		DUK_ERROR((duk_hthread *) ctx, DUK_ERR_RANGE_ERROR, DUK_STR_JSONENC_RECLIMIT);
-+	}
-+	js_ctx->recursion_depth++;
-+
-+	/* figure out indent and stepback */
-+
-+	*h_indent = NULL;
-+	*h_stepback = NULL;
-+	if (js_ctx->h_gap != NULL) {
-+		DUK_ASSERT(js_ctx->h_indent != NULL);
-+
-+		*h_stepback = js_ctx->h_indent;
-+		duk_push_hstring(ctx, js_ctx->h_indent);
-+		duk_push_hstring(ctx, js_ctx->h_gap);
-+		duk_concat(ctx, 2);
-+		js_ctx->h_indent = duk_get_hstring(ctx, -1);
-+		*h_indent = js_ctx->h_indent;
-+		DUK_ASSERT(js_ctx->h_indent != NULL);
-+
-+		/* The new indent string is left at value stack top, and will
-+		 * be popped by the shared exit handler.
-+		 */
-+	} else {
-+		DUK_ASSERT(js_ctx->h_indent == NULL);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T",
-+	                     (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop)));
-+}
-+
-+/* Shared exit handling for object/array serialization. */
-+DUK_LOCAL void duk__enc_objarr_exit(duk_json_enc_ctx *js_ctx, duk_hstring **h_stepback, duk_hstring **h_indent, duk_idx_t *entry_top) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_hobject *h_target;
-+
-+	DUK_UNREF(h_indent);
-+
-+	if (js_ctx->h_gap != NULL) {
-+		DUK_ASSERT(js_ctx->h_indent != NULL);
-+		DUK_ASSERT(*h_stepback != NULL);
-+		DUK_ASSERT(*h_indent != NULL);
-+
-+		js_ctx->h_indent = *h_stepback;  /* previous js_ctx->h_indent */
-+
-+		/* Note: we don't need to pop anything because the duk_set_top()
-+		 * at the end will take care of it.
-+		 */
-+	} else {
-+		DUK_ASSERT(js_ctx->h_indent == NULL);
-+		DUK_ASSERT(*h_stepback == NULL);
-+		DUK_ASSERT(*h_indent == NULL);
-+	}
-+
-+	/* c recursion check */
-+
-+	DUK_ASSERT(js_ctx->recursion_depth > 0);
-+	DUK_ASSERT(js_ctx->recursion_depth <= js_ctx->recursion_limit);
-+	js_ctx->recursion_depth--;
-+
-+	/* loop check */
-+
-+	h_target = duk_get_hobject(ctx, *entry_top - 1);  /* original target at entry_top - 1 */
-+	DUK_ASSERT(h_target != NULL);
-+	duk_push_sprintf(ctx, DUK_STR_FMT_PTR, (void *) h_target);
-+
-+	duk_del_prop(ctx, js_ctx->idx_loop);  /* -> [ ... ] */
-+
-+	/* restore stack top after unbalanced code paths */
-+	duk_set_top(ctx, *entry_top);
-+
-+	DUK_DDD(DUK_DDDPRINT("shared entry finished: top=%ld, loop=%!T",
-+	                     (long) duk_get_top(ctx), (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop)));
-+}
-+
-+/* The JO(value) operation: encode object.
-+ *
-+ * Stack policy: [ object ] -> [ object ].
-+ */
-+DUK_LOCAL void duk__enc_object(duk_json_enc_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_hstring *h_stepback;
-+	duk_hstring *h_indent;
-+	duk_hstring *h_key;
-+	duk_idx_t entry_top;
-+	duk_idx_t idx_obj;
-+	duk_idx_t idx_keys;
-+	duk_bool_t first;
-+	duk_bool_t undef;
-+	duk_uarridx_t arr_len, i;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__enc_object: obj=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	duk__enc_objarr_entry(js_ctx, &h_stepback, &h_indent, &entry_top);
-+
-+	idx_obj = entry_top - 1;
-+
-+	if (js_ctx->idx_proplist >= 0) {
-+		idx_keys = js_ctx->idx_proplist;
-+	} else {
-+		/* XXX: would be nice to enumerate an object at specified index */
-+		duk_dup(ctx, idx_obj);
-+		(void) duk_hobject_get_enumerated_keys(ctx, DUK_ENUM_OWN_PROPERTIES_ONLY /*flags*/);  /* [ ... target ] -> [ ... target keys ] */
-+		idx_keys = duk_require_normalize_index(ctx, -1);
-+		/* leave stack unbalanced on purpose */
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("idx_keys=%ld, h_keys=%!T",
-+	                     (long) idx_keys, (duk_tval *) duk_get_tval(ctx, idx_keys)));
-+
-+	/* Steps 8-10 have been merged to avoid a "partial" variable. */
-+
-+	DUK__EMIT_1(js_ctx, DUK_ASC_LCURLY);
-+
-+	/* XXX: keys is an internal object with all keys to be processed
-+	 * in its (gapless) array part.  Because nobody can touch the keys
-+	 * object, we could iterate its array part directly (keeping in mind
-+	 * that it can be reallocated).
-+	 */
-+
-+	arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_keys);
-+	first = 1;
-+	for (i = 0; i < arr_len; i++) {
-+		duk_get_prop_index(ctx, idx_keys, i);  /* -> [ ... key ] */
-+
-+		DUK_DDD(DUK_DDDPRINT("object property loop: holder=%!T, key=%!T",
-+		                     (duk_tval *) duk_get_tval(ctx, idx_obj),
-+		                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+		undef = duk__enc_value1(js_ctx, idx_obj);
-+		if (undef) {
-+			/* Value would yield 'undefined', so skip key altogether.
-+			 * Side effects have already happened.
-+			 */
-+			continue;
-+		}
-+
-+		/* [ ... key val ] */
-+
-+		if (first) {
-+			first = 0;
-+		} else {
-+			DUK__EMIT_1(js_ctx, DUK_ASC_COMMA);
-+		}
-+		if (h_indent != NULL) {
-+			DUK__EMIT_1(js_ctx, 0x0a);
-+			DUK__EMIT_HSTR(js_ctx, h_indent);
-+		}
-+
-+		h_key = duk_get_hstring(ctx, -2);
-+		DUK_ASSERT(h_key != NULL);
-+		if (js_ctx->flag_avoid_key_quotes && !duk__enc_key_quotes_needed(h_key)) {
-+			/* emit key as is */
-+			DUK__EMIT_HSTR(js_ctx, h_key);
-+		} else {
-+			duk__enc_quote_string(js_ctx, h_key);
-+		}
-+
-+		if (h_indent != NULL) {
-+			DUK__EMIT_2(js_ctx, DUK_ASC_COLON, DUK_ASC_SPACE);
-+		} else {
-+			DUK__EMIT_1(js_ctx, DUK_ASC_COLON);
-+		}
-+
-+		/* [ ... key val ] */
-+
-+		duk__enc_value2(js_ctx);  /* -> [ ... ] */
-+	}
-+
-+	if (!first) {
-+		if (h_stepback != NULL) {
-+			DUK_ASSERT(h_indent != NULL);
-+			DUK__EMIT_1(js_ctx, 0x0a);
-+			DUK__EMIT_HSTR(js_ctx, h_stepback);
-+		}
-+	}
-+	DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY);
-+
-+	duk__enc_objarr_exit(js_ctx, &h_stepback, &h_indent, &entry_top);
-+
-+	DUK_ASSERT_TOP(ctx, entry_top);
-+}
-+
-+/* The JA(value) operation: encode array.
-+ *
-+ * Stack policy: [ array ] -> [ array ].
-+ */
-+DUK_LOCAL void duk__enc_array(duk_json_enc_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_hstring *h_stepback;
-+	duk_hstring *h_indent;
-+	duk_idx_t entry_top;
-+	duk_idx_t idx_arr;
-+	duk_bool_t undef;
-+	duk_uarridx_t i, arr_len;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__enc_array: array=%!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	duk__enc_objarr_entry(js_ctx, &h_stepback, &h_indent, &entry_top);
-+
-+	idx_arr = entry_top - 1;
-+
-+	/* Steps 8-10 have been merged to avoid a "partial" variable. */
-+
-+	DUK__EMIT_1(js_ctx, DUK_ASC_LBRACKET);
-+
-+	arr_len = (duk_uarridx_t) duk_get_length(ctx, idx_arr);
-+	for (i = 0; i < arr_len; i++) {
-+		DUK_DDD(DUK_DDDPRINT("array entry loop: array=%!T, h_indent=%!O, h_stepback=%!O, index=%ld, arr_len=%ld",
-+		                     (duk_tval *) duk_get_tval(ctx, idx_arr), (duk_heaphdr *) h_indent,
-+		                     (duk_heaphdr *) h_stepback, (long) i, (long) arr_len));
-+
-+		if (i > 0) {
-+			DUK__EMIT_1(js_ctx, DUK_ASC_COMMA);
-+		}
-+		if (h_indent != NULL) {
-+			DUK__EMIT_1(js_ctx, 0x0a);
-+			DUK__EMIT_HSTR(js_ctx, h_indent);
-+		}
-+
-+		/* XXX: duk_push_uint_string() */
-+		duk_push_uint(ctx, (duk_uint_t) i);
-+		duk_to_string(ctx, -1);  /* -> [ ... key ] */
-+		undef = duk__enc_value1(js_ctx, idx_arr);
-+
-+		if (undef) {
-+			DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL);
-+		} else {
-+			/* [ ... key val ] */
-+			duk__enc_value2(js_ctx);
-+		}
-+	}
-+
-+	if (arr_len > 0) {
-+		if (h_stepback != NULL) {
-+			DUK_ASSERT(h_indent != NULL);
-+			DUK__EMIT_1(js_ctx, 0x0a);
-+			DUK__EMIT_HSTR(js_ctx, h_stepback);
-+		}
-+	}
-+	DUK__EMIT_1(js_ctx, DUK_ASC_RBRACKET);
-+
-+	duk__enc_objarr_exit(js_ctx, &h_stepback, &h_indent, &entry_top);
-+
-+	DUK_ASSERT_TOP(ctx, entry_top);
-+}
-+
-+/* The Str(key, holder) operation: encode value, steps 1-4.
-+ *
-+ * Returns non-zero if the value between steps 4 and 5 would yield an
-+ * 'undefined' final result.  This is useful in JO() because we need to
-+ * get the side effects out, but need to know whether or not a key will
-+ * be omitted from the serialization.
-+ *
-+ * Stack policy: [ ... key ] -> [ ... key val ]  if retval == 0.
-+ *                           -> [ ... ]          if retval != 0.
-+ */
-+DUK_LOCAL duk_bool_t duk__enc_value1(duk_json_enc_ctx *js_ctx, duk_idx_t idx_holder) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_hobject *h;
-+	duk_tval *tv;
-+	duk_small_int_t c;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__enc_value1: idx_holder=%ld, holder=%!T, key=%!T",
-+	                     (long) idx_holder, (duk_tval *) duk_get_tval(ctx, idx_holder),
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	duk_dup_top(ctx);               /* -> [ ... key key ] */
-+	duk_get_prop(ctx, idx_holder);  /* -> [ ... key val ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	h = duk_get_hobject_or_lfunc_coerce(ctx, -1);
-+	if (h != NULL) {
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_TO_JSON);
-+		h = duk_get_hobject_or_lfunc_coerce(ctx, -1);  /* toJSON() can also be a lightfunc */
-+
-+		if (h != NULL && DUK_HOBJECT_IS_CALLABLE(h)) {
-+			DUK_DDD(DUK_DDDPRINT("value is object, has callable toJSON() -> call it"));
-+			duk_dup(ctx, -2);         /* -> [ ... key val toJSON val ] */
-+			duk_dup(ctx, -4);         /* -> [ ... key val toJSON val key ] */
-+			duk_call_method(ctx, 1);  /* -> [ ... key val val' ] */
-+			duk_remove(ctx, -2);      /* -> [ ... key val' ] */
-+		} else {
-+			duk_pop(ctx);
-+		}
-+	}
-+
-+	/* [ ... key val ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	if (js_ctx->h_replacer) {
-+		/* XXX: here a "slice copy" would be useful */
-+		DUK_DDD(DUK_DDDPRINT("replacer is set, call replacer"));
-+		duk_push_hobject(ctx, js_ctx->h_replacer);  /* -> [ ... key val replacer ] */
-+		duk_dup(ctx, idx_holder);                   /* -> [ ... key val replacer holder ] */
-+		duk_dup(ctx, -4);                           /* -> [ ... key val replacer holder key ] */
-+		duk_dup(ctx, -4);                           /* -> [ ... key val replacer holder key val ] */
-+		duk_call_method(ctx, 2);                    /* -> [ ... key val val' ] */
-+		duk_remove(ctx, -2);                        /* -> [ ... key val' ] */
-+	}
-+
-+	/* [ ... key val ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	tv = duk_get_tval(ctx, -1);
-+	DUK_ASSERT(tv != NULL);
-+	if (DUK_TVAL_IS_OBJECT(tv)) {
-+		h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+
-+		c = (duk_small_int_t) DUK_HOBJECT_GET_CLASS_NUMBER(h);
-+		switch ((int) c) {
-+		case DUK_HOBJECT_CLASS_NUMBER:
-+			DUK_DDD(DUK_DDDPRINT("value is a Number object -> coerce with ToNumber()"));
-+			duk_to_number(ctx, -1);
-+			break;
-+		case DUK_HOBJECT_CLASS_STRING:
-+			DUK_DDD(DUK_DDDPRINT("value is a String object -> coerce with ToString()"));
-+			duk_to_string(ctx, -1);
-+			break;
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+		case DUK_HOBJECT_CLASS_BUFFER:
-+		case DUK_HOBJECT_CLASS_POINTER:
-+#endif
-+		case DUK_HOBJECT_CLASS_BOOLEAN:
-+			DUK_DDD(DUK_DDDPRINT("value is a Boolean/Buffer/Pointer object -> get internal value"));
-+			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-+			duk_remove(ctx, -2);
-+			break;
-+		}
-+	}
-+
-+	/* [ ... key val ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("value=%!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	if (duk_check_type_mask(ctx, -1, js_ctx->mask_for_undefined)) {
-+		/* will result in undefined */
-+		DUK_DDD(DUK_DDDPRINT("-> will result in undefined (type mask check)"));
-+		goto undef;
-+	}
-+
-+	/* functions are detected specially */
-+	h = duk_get_hobject(ctx, -1);
-+	if (h != NULL && DUK_HOBJECT_IS_CALLABLE(h)) {
-+		if (js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM |
-+		                     DUK_JSON_FLAG_EXT_COMPATIBLE)) {
-+			/* function will be serialized to custom format */
-+		} else {
-+			/* functions are not serialized, results in undefined */
-+			DUK_DDD(DUK_DDDPRINT("-> will result in undefined (function)"));
-+			goto undef;
-+		}
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("-> will not result in undefined"));
-+	return 0;
-+
-+ undef:
-+	duk_pop_2(ctx);
-+	return 1;
-+}
-+
-+/* The Str(key, holder) operation: encode value, steps 5-10.
-+ *
-+ * This must not be called unless duk__enc_value1() returns non-zero.
-+ * If so, this is guaranteed to produce a non-undefined result.
-+ * Non-standard encodings (e.g. for undefined) are only used if
-+ * duk__enc_value1() indicates they are accepted; they're not
-+ * checked or asserted here again.
-+ *
-+ * Stack policy: [ ... key val ] -> [ ... ].
-+ */
-+DUK_LOCAL void duk__enc_value2(duk_json_enc_ctx *js_ctx) {
-+	duk_context *ctx = (duk_context *) js_ctx->thr;
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv;
-+
-+	DUK_UNREF(thr);
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__enc_value2: key=%!T, val=%!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -2),
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/* [ ... key val ] */
-+
-+	tv = duk_get_tval(ctx, -1);
-+	DUK_ASSERT(tv != NULL);
-+
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+	/* When JX/JC not in use, duk__enc_value1 will block undefined values. */
-+	case DUK_TAG_UNDEFINED: {
-+		DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_undefined);
-+		break;
-+	}
-+#endif
-+	case DUK_TAG_NULL: {
-+		DUK__EMIT_STRIDX(js_ctx, DUK_STRIDX_LC_NULL);
-+		break;
-+	}
-+	case DUK_TAG_BOOLEAN: {
-+		DUK__EMIT_STRIDX(js_ctx, DUK_TVAL_GET_BOOLEAN(tv) ?
-+		                 DUK_STRIDX_TRUE : DUK_STRIDX_FALSE);
-+		break;
-+	}
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+	/* When JX/JC not in use, duk__enc_value1 will block pointer values. */
-+	case DUK_TAG_POINTER: {
-+		char buf[64];  /* XXX: how to figure correct size? */
-+		const char *fmt;
-+		void *ptr = DUK_TVAL_GET_POINTER(tv);
-+
-+		DUK_MEMZERO(buf, sizeof(buf));
-+
-+		/* The #ifdef clutter here needs to handle the three cases:
-+		 * (1) JX+JC, (2) JX only, (3) JC only.
-+		 */
-+#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
-+		if (js_ctx->flag_ext_custom)
-+#endif
-+#if defined(DUK_USE_JX)
-+		{
-+			fmt = ptr ? "(%p)" : "(null)";
-+		}
-+#endif
-+#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
-+		else
-+#endif
-+#if defined(DUK_USE_JC)
-+		{
-+			fmt = ptr ? "{\"_ptr\":\"%p\"}" : "{\"_ptr\":\"null\"}";
-+		}
-+#endif
-+
-+		/* When ptr == NULL, the format argument is unused. */
-+		DUK_SNPRINTF(buf, sizeof(buf) - 1, fmt, ptr);  /* must not truncate */
-+		DUK__EMIT_CSTR(js_ctx, buf);
-+		break;
-+	}
-+#endif  /* DUK_USE_JX || DUK_USE_JC */
-+	case DUK_TAG_STRING: {
-+		duk_hstring *h = DUK_TVAL_GET_STRING(tv);
-+		DUK_ASSERT(h != NULL);
-+
-+		duk__enc_quote_string(js_ctx, h);
-+		break;
-+	}
-+	case DUK_TAG_OBJECT: {
-+		duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+		if (DUK_HOBJECT_IS_CALLABLE(h)) {
-+			/* We only get here when doing non-standard JSON encoding */
-+			DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible);
-+			DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_function);
-+		} else  /* continues below */
-+#endif
-+		if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) {
-+			duk__enc_array(js_ctx);
-+		} else {
-+			duk__enc_object(js_ctx);
-+		}
-+		break;
-+	}
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+	/* When JX/JC not in use, duk__enc_value1 will block buffer values. */
-+	case DUK_TAG_BUFFER: {
-+		/* Buffer values are encoded in (lowercase) hex to make the
-+		 * binary data readable.  Base64 or similar would be more
-+		 * compact but less readable, and the point of JX/JC
-+		 * variants is to be as useful to a programmer as possible.
-+		 */
-+
-+		/* The #ifdef clutter here needs to handle the three cases:
-+		 * (1) JX+JC, (2) JX only, (3) JC only.
-+		 */
-+#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
-+		if (js_ctx->flag_ext_custom)
-+#endif
-+#if defined(DUK_USE_JX)
-+		{
-+			duk_uint8_t *p, *p_end;
-+			duk_small_uint_t x;
-+			duk_hbuffer *h;
-+
-+			h = DUK_TVAL_GET_BUFFER(tv);
-+			DUK_ASSERT(h != NULL);
-+			p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);
-+			p_end = p + DUK_HBUFFER_GET_SIZE(h);
-+			DUK__EMIT_1(js_ctx, DUK_ASC_PIPE);
-+			while (p < p_end) {
-+				x = *p++;
-+				duk_hbuffer_append_byte(js_ctx->thr, js_ctx->h_buf, duk_lc_digits[(x >> 4) & 0x0f]);
-+				duk_hbuffer_append_byte(js_ctx->thr, js_ctx->h_buf, duk_lc_digits[x & 0x0f]);
-+			}
-+			DUK__EMIT_1(js_ctx, DUK_ASC_PIPE);
-+		}
-+#endif
-+#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
-+		else
-+#endif
-+#if defined(DUK_USE_JC)
-+		{
-+			DUK_ASSERT(js_ctx->flag_ext_compatible);
-+			duk_hex_encode(ctx, -1);
-+			DUK__EMIT_CSTR(js_ctx, "{\"_buf\":");
-+			duk__enc_quote_string(js_ctx, duk_require_hstring(ctx, -1));
-+			DUK__EMIT_1(js_ctx, DUK_ASC_RCURLY);
-+		}
-+#endif
-+		break;
-+	}
-+#endif  /* DUK_USE_JX || DUK_USE_JC */
-+	case DUK_TAG_LIGHTFUNC: {
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+		/* We only get here when doing non-standard JSON encoding */
-+		DUK_ASSERT(js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible);
-+		DUK__EMIT_STRIDX(js_ctx, js_ctx->stridx_custom_function);
-+#else
-+		/* Standard JSON omits functions */
-+		DUK_UNREACHABLE();
-+#endif
-+		break;
-+	}
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default: {
-+		/* number */
-+		duk_double_t d;
-+		duk_small_int_t c;
-+		duk_small_int_t s;
-+		duk_small_uint_t stridx;
-+		duk_small_uint_t n2s_flags;
-+		duk_hstring *h_str;
-+
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		d = DUK_TVAL_GET_NUMBER(tv);
-+		c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-+		s = (duk_small_int_t) DUK_SIGNBIT(d);
-+		DUK_UNREF(s);
-+
-+		if (DUK_LIKELY(!(c == DUK_FP_INFINITE || c == DUK_FP_NAN))) {
-+			DUK_ASSERT(DUK_ISFINITE(d));
-+
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+			/* Negative zero needs special handling in JX/JC because
-+			 * it would otherwise serialize to '0', not '-0'.
-+			 */
-+			if (DUK_UNLIKELY(c == DUK_FP_ZERO && s != 0 &&
-+			                 (js_ctx->flag_ext_custom || js_ctx->flag_ext_compatible))) {
-+				duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_ZERO);  /* '-0' */
-+			} else
-+#endif  /* DUK_USE_JX || DUK_USE_JC */
-+			{
-+				n2s_flags = 0;
-+				/* [ ... number ] -> [ ... string ] */
-+				duk_numconv_stringify(ctx, 10 /*radix*/, 0 /*digits*/, n2s_flags);
-+			}
-+			h_str = duk_to_hstring(ctx, -1);
-+			DUK_ASSERT(h_str != NULL);
-+			DUK__EMIT_HSTR(js_ctx, h_str);
-+			break;
-+		}
-+
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+		if (!(js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM |
-+		                       DUK_JSON_FLAG_EXT_COMPATIBLE))) {
-+			stridx = DUK_STRIDX_LC_NULL;
-+		} else if (c == DUK_FP_NAN) {
-+			stridx = js_ctx->stridx_custom_nan;
-+		} else if (s == 0) {
-+			stridx = js_ctx->stridx_custom_posinf;
-+		} else {
-+			stridx = js_ctx->stridx_custom_neginf;
-+		}
-+#else
-+		stridx = DUK_STRIDX_LC_NULL;
-+#endif
-+		DUK__EMIT_STRIDX(js_ctx, stridx);
-+		break;
-+	}
-+	}
-+
-+	/* [ ... key val ] -> [ ... ] */
-+
-+	duk_pop_2(ctx);
-+}
-+
-+/* E5 Section 15.12.3, main algorithm, step 4.b.ii steps 1-4. */
-+DUK_LOCAL duk_bool_t duk__enc_allow_into_proplist(duk_tval *tv) {
-+	duk_hobject *h;
-+	duk_small_int_t c;
-+
-+	DUK_ASSERT(tv != NULL);
-+	if (DUK_TVAL_IS_STRING(tv) || DUK_TVAL_IS_NUMBER(tv)) {
-+		return 1;
-+	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-+		h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+		c = (duk_small_int_t) DUK_HOBJECT_GET_CLASS_NUMBER(h);
-+		if (c == DUK_HOBJECT_CLASS_STRING || c == DUK_HOBJECT_CLASS_NUMBER) {
-+			return 1;
-+		}
-+	}
-+
-+	return 0;
-+}
-+
-+/*
-+ *  Top level wrappers
-+ */
-+
-+DUK_INTERNAL
-+void duk_bi_json_parse_helper(duk_context *ctx,
-+                              duk_idx_t idx_value,
-+                              duk_idx_t idx_reviver,
-+                              duk_small_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_json_dec_ctx js_ctx_alloc;
-+	duk_json_dec_ctx *js_ctx = &js_ctx_alloc;
-+	duk_hstring *h_text;
-+#ifdef DUK_USE_ASSERTIONS
-+	duk_idx_t entry_top = duk_get_top(ctx);
-+#endif
-+
-+	/* negative top-relative indices not allowed now */
-+	DUK_ASSERT(idx_value == DUK_INVALID_INDEX || idx_value >= 0);
-+	DUK_ASSERT(idx_reviver == DUK_INVALID_INDEX || idx_reviver >= 0);
-+
-+	DUK_DDD(DUK_DDDPRINT("JSON parse start: text=%!T, reviver=%!T, flags=0x%08lx, stack_top=%ld",
-+	                     (duk_tval *) duk_get_tval(ctx, idx_value),
-+	                     (duk_tval *) duk_get_tval(ctx, idx_reviver),
-+	                     (unsigned long) flags,
-+	                     (long) duk_get_top(ctx)));
-+
-+	DUK_MEMZERO(&js_ctx_alloc, sizeof(js_ctx_alloc));
-+	js_ctx->thr = thr;
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	/* nothing now */
-+#endif
-+	js_ctx->recursion_limit = DUK_JSON_DEC_RECURSION_LIMIT;
-+
-+	/* Flag handling currently assumes that flags are consistent.  This is OK
-+	 * because the call sites are now strictly controlled.
-+	 */
-+
-+	js_ctx->flags = flags;
-+#ifdef DUK_USE_JX
-+	js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM;
-+#endif
-+#ifdef DUK_USE_JC
-+	js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE;
-+#endif
-+
-+	h_text = duk_to_hstring(ctx, idx_value);  /* coerce in-place */
-+	DUK_ASSERT(h_text != NULL);
-+
-+	js_ctx->p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text);
-+	js_ctx->p = js_ctx->p_start;
-+	js_ctx->p_end = ((duk_uint8_t *) DUK_HSTRING_GET_DATA(h_text)) +
-+	                DUK_HSTRING_GET_BYTELEN(h_text);
-+
-+	duk__dec_value(js_ctx);  /* -> [ ... value ] */
-+
-+	/* Trailing whitespace has been eaten by duk__dec_value(), so if
-+	 * we're not at end of input here, it's a SyntaxError.
-+	 */
-+
-+	if (js_ctx->p != js_ctx->p_end) {
-+		duk__dec_syntax_error(js_ctx);
-+	}
-+
-+	if (duk_is_callable(ctx, idx_reviver)) {
-+		DUK_DDD(DUK_DDDPRINT("applying reviver: %!T",
-+		                     (duk_tval *) duk_get_tval(ctx, idx_reviver)));
-+
-+		js_ctx->idx_reviver = idx_reviver;
-+
-+		duk_push_object(ctx);
-+		duk_dup(ctx, -2);  /* -> [ ... val root val ] */
-+		duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING);  /* default attrs ok */
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);  /* -> [ ... val root "" ] */
-+
-+		DUK_DDD(DUK_DDDPRINT("start reviver walk, root=%!T, name=%!T",
-+		                     (duk_tval *) duk_get_tval(ctx, -2),
-+		                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+		duk__dec_reviver_walk(js_ctx);  /* [ ... val root "" ] -> [ ... val val' ] */
-+		duk_remove(ctx, -2);            /* -> [ ... val' ] */
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("reviver does not exist or is not callable: %!T",
-+		                     (duk_tval *) duk_get_tval(ctx, idx_reviver)));
-+	}
-+
-+	/* Final result is at stack top. */
-+
-+	DUK_DDD(DUK_DDDPRINT("JSON parse end: text=%!T, reviver=%!T, flags=0x%08lx, result=%!T, stack_top=%ld",
-+	                     (duk_tval *) duk_get_tval(ctx, idx_value),
-+	                     (duk_tval *) duk_get_tval(ctx, idx_reviver),
-+	                     (unsigned long) flags,
-+	                     (duk_tval *) duk_get_tval(ctx, -1),
-+	                     (long) duk_get_top(ctx)));
-+
-+	DUK_ASSERT(duk_get_top(ctx) == entry_top + 1);
-+}
-+
-+DUK_INTERNAL
-+void duk_bi_json_stringify_helper(duk_context *ctx,
-+                                  duk_idx_t idx_value,
-+                                  duk_idx_t idx_replacer,
-+                                  duk_idx_t idx_space,
-+                                  duk_small_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_json_enc_ctx js_ctx_alloc;
-+	duk_json_enc_ctx *js_ctx = &js_ctx_alloc;
-+	duk_hobject *h;
-+	duk_bool_t undef;
-+	duk_idx_t idx_holder;
-+	duk_idx_t entry_top;
-+
-+	/* negative top-relative indices not allowed now */
-+	DUK_ASSERT(idx_value == DUK_INVALID_INDEX || idx_value >= 0);
-+	DUK_ASSERT(idx_replacer == DUK_INVALID_INDEX || idx_replacer >= 0);
-+	DUK_ASSERT(idx_space == DUK_INVALID_INDEX || idx_space >= 0);
-+
-+	DUK_DDD(DUK_DDDPRINT("JSON stringify start: value=%!T, replacer=%!T, space=%!T, flags=0x%08lx, stack_top=%ld",
-+	                     (duk_tval *) duk_get_tval(ctx, idx_value),
-+	                     (duk_tval *) duk_get_tval(ctx, idx_replacer),
-+	                     (duk_tval *) duk_get_tval(ctx, idx_space),
-+	                     (unsigned long) flags,
-+	                     (long) duk_get_top(ctx)));
-+
-+	entry_top = duk_get_top(ctx);
-+
-+	/*
-+	 *  Context init
-+	 */
-+
-+	DUK_MEMZERO(&js_ctx_alloc, sizeof(js_ctx_alloc));
-+	js_ctx->thr = thr;
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	js_ctx->h_replacer = NULL;
-+	js_ctx->h_gap = NULL;
-+	js_ctx->h_indent = NULL;
-+#endif
-+	js_ctx->idx_proplist = -1;
-+	js_ctx->recursion_limit = DUK_JSON_ENC_RECURSION_LIMIT;
-+
-+	/* Flag handling currently assumes that flags are consistent.  This is OK
-+	 * because the call sites are now strictly controlled.
-+	 */
-+
-+	js_ctx->flags = flags;
-+	js_ctx->flag_ascii_only = flags & DUK_JSON_FLAG_ASCII_ONLY;
-+	js_ctx->flag_avoid_key_quotes = flags & DUK_JSON_FLAG_AVOID_KEY_QUOTES;
-+#ifdef DUK_USE_JX
-+	js_ctx->flag_ext_custom = flags & DUK_JSON_FLAG_EXT_CUSTOM;
-+#endif
-+#ifdef DUK_USE_JC
-+	js_ctx->flag_ext_compatible = flags & DUK_JSON_FLAG_EXT_COMPATIBLE;
-+#endif
-+
-+	/* The #ifdef clutter here handles the JX/JC enable/disable
-+	 * combinations properly.
-+	 */
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+#if defined(DUK_USE_JX)
-+	if (flags & DUK_JSON_FLAG_EXT_CUSTOM) {
-+		js_ctx->stridx_custom_undefined = DUK_STRIDX_LC_UNDEFINED;
-+		js_ctx->stridx_custom_nan = DUK_STRIDX_NAN;
-+		js_ctx->stridx_custom_neginf = DUK_STRIDX_MINUS_INFINITY;
-+		js_ctx->stridx_custom_posinf = DUK_STRIDX_INFINITY;
-+		js_ctx->stridx_custom_function =
-+		        (flags & DUK_JSON_FLAG_AVOID_KEY_QUOTES) ?
-+		                DUK_STRIDX_JSON_EXT_FUNCTION2 :
-+		                DUK_STRIDX_JSON_EXT_FUNCTION1;
-+	}
-+#endif  /* DUK_USE_JX */
-+#if defined(DUK_USE_JX) && defined(DUK_USE_JC)
-+	else
-+#endif  /* DUK_USE_JX && DUK_USE_JC */
-+#if defined(DUK_USE_JC)
-+	if (js_ctx->flags & DUK_JSON_FLAG_EXT_COMPATIBLE) {
-+		js_ctx->stridx_custom_undefined = DUK_STRIDX_JSON_EXT_UNDEFINED;
-+		js_ctx->stridx_custom_nan = DUK_STRIDX_JSON_EXT_NAN;
-+		js_ctx->stridx_custom_neginf = DUK_STRIDX_JSON_EXT_NEGINF;
-+		js_ctx->stridx_custom_posinf = DUK_STRIDX_JSON_EXT_POSINF;
-+		js_ctx->stridx_custom_function = DUK_STRIDX_JSON_EXT_FUNCTION1;
-+	}
-+#endif  /* DUK_USE_JC */
-+#endif  /* DUK_USE_JX || DUK_USE_JC */
-+
-+#if defined(DUK_USE_JX) || defined(DUK_USE_JC)
-+	if (js_ctx->flags & (DUK_JSON_FLAG_EXT_CUSTOM |
-+	                     DUK_JSON_FLAG_EXT_COMPATIBLE)) {
-+		DUK_ASSERT(js_ctx->mask_for_undefined == 0);  /* already zero */
-+	}
-+	else
-+#endif  /* DUK_USE_JX || DUK_USE_JC */
-+	{
-+		js_ctx->mask_for_undefined = DUK_TYPE_MASK_UNDEFINED |
-+		                             DUK_TYPE_MASK_POINTER |
-+		                             DUK_TYPE_MASK_BUFFER |
-+		                             DUK_TYPE_MASK_LIGHTFUNC;
-+	}
-+
-+	(void) duk_push_dynamic_buffer(ctx, 0);
-+	js_ctx->h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(js_ctx->h_buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(js_ctx->h_buf));
-+
-+	js_ctx->idx_loop = duk_push_object_internal(ctx);
-+	DUK_ASSERT(js_ctx->idx_loop >= 0);
-+
-+	/* [ ... buf loop ] */
-+
-+	/*
-+	 *  Process replacer/proplist (2nd argument to JSON.stringify)
-+	 */
-+
-+	h = duk_get_hobject(ctx, idx_replacer);
-+	if (h != NULL) {
-+		if (DUK_HOBJECT_IS_CALLABLE(h)) {
-+			js_ctx->h_replacer = h;
-+		} else if (DUK_HOBJECT_GET_CLASS_NUMBER(h) == DUK_HOBJECT_CLASS_ARRAY) {
-+			/* Here the specification requires correct array index enumeration
-+			 * which is a bit tricky for sparse arrays (it is handled by the
-+			 * enum setup code).  We now enumerate ancestors too, although the
-+			 * specification is not very clear on whether that is required.
-+			 */
-+
-+			duk_uarridx_t plist_idx = 0;
-+			duk_small_uint_t enum_flags;
-+
-+			js_ctx->idx_proplist = duk_push_array(ctx);  /* XXX: array internal? */
-+
-+			enum_flags = DUK_ENUM_ARRAY_INDICES_ONLY |
-+			             DUK_ENUM_SORT_ARRAY_INDICES;  /* expensive flag */
-+			duk_enum(ctx, idx_replacer, enum_flags);
-+			while (duk_next(ctx, -1 /*enum_index*/, 1 /*get_value*/)) {
-+				/* [ ... proplist enum_obj key val ] */
-+				if (duk__enc_allow_into_proplist(duk_get_tval(ctx, -1))) {
-+					/* XXX: duplicates should be eliminated here */
-+					DUK_DDD(DUK_DDDPRINT("proplist enum: key=%!T, val=%!T --> accept",
-+					                     (duk_tval *) duk_get_tval(ctx, -2),
-+					                     (duk_tval *) duk_get_tval(ctx, -1)));
-+					duk_to_string(ctx, -1);  /* extra coercion of strings is OK */
-+					duk_put_prop_index(ctx, -4, plist_idx);  /* -> [ ... proplist enum_obj key ] */
-+					plist_idx++;
-+					duk_pop(ctx);
-+				} else {
-+					DUK_DDD(DUK_DDDPRINT("proplist enum: key=%!T, val=%!T --> reject",
-+					                     (duk_tval *) duk_get_tval(ctx, -2),
-+					                     (duk_tval *) duk_get_tval(ctx, -1)));
-+					duk_pop_2(ctx);
-+				}
-+                        }
-+                        duk_pop(ctx);  /* pop enum */
-+
-+			/* [ ... proplist ] */
-+		}
-+	}
-+
-+	/* [ ... buf loop (proplist) ] */
-+
-+	/*
-+	 *  Process space (3rd argument to JSON.stringify)
-+	 */
-+
-+	h = duk_get_hobject(ctx, idx_space);
-+	if (h != NULL) {
-+		int c = DUK_HOBJECT_GET_CLASS_NUMBER(h);
-+		if (c == DUK_HOBJECT_CLASS_NUMBER) {
-+			duk_to_number(ctx, idx_space);
-+		} else if (c == DUK_HOBJECT_CLASS_STRING) {
-+			duk_to_string(ctx, idx_space);
-+		}
-+	}
-+
-+	if (duk_is_number(ctx, idx_space)) {
-+		duk_small_int_t nspace;
-+		/* spaces[] must be static to allow initializer with old compilers like BCC */
-+		static const char spaces[10] = {
-+			DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE,
-+			DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE, DUK_ASC_SPACE,
-+			DUK_ASC_SPACE, DUK_ASC_SPACE
-+		};  /* XXX: helper */
-+
-+		/* ToInteger() coercion; NaN -> 0, infinities are clamped to 0 and 10 */
-+		nspace = (duk_small_int_t) duk_to_int_clamped(ctx, idx_space, 0 /*minval*/, 10 /*maxval*/);
-+		DUK_ASSERT(nspace >= 0 && nspace <= 10);
-+
-+		duk_push_lstring(ctx, spaces, (duk_size_t) nspace);
-+		js_ctx->h_gap = duk_get_hstring(ctx, -1);
-+		DUK_ASSERT(js_ctx->h_gap != NULL);
-+	} else if (duk_is_string(ctx, idx_space)) {
-+		/* XXX: substring in-place at idx_place? */
-+		duk_dup(ctx, idx_space);
-+		duk_substring(ctx, -1, 0, 10);  /* clamp to 10 chars */
-+		js_ctx->h_gap = duk_get_hstring(ctx, -1);
-+		DUK_ASSERT(js_ctx->h_gap != NULL);
-+	} else {
-+		/* nop */
-+	}
-+
-+	if (js_ctx->h_gap != NULL) {
-+		/* if gap is empty, behave as if not given at all */
-+		if (DUK_HSTRING_GET_CHARLEN(js_ctx->h_gap) == 0) {
-+			js_ctx->h_gap = NULL;
-+		} else {
-+			/* set 'indent' only if it will actually increase */
-+			js_ctx->h_indent = DUK_HTHREAD_STRING_EMPTY_STRING(thr);
-+		}
-+	}
-+
-+	DUK_ASSERT((js_ctx->h_gap == NULL && js_ctx->h_indent == NULL) ||
-+	           (js_ctx->h_gap != NULL && js_ctx->h_indent != NULL));
-+
-+	/* [ ... buf loop (proplist) (gap) ] */
-+
-+	/*
-+	 *  Create wrapper object and serialize
-+	 */
-+
-+	idx_holder = duk_push_object(ctx);
-+	duk_dup(ctx, idx_value);
-+	duk_put_prop_stridx(ctx, -2, DUK_STRIDX_EMPTY_STRING);
-+
-+	DUK_DDD(DUK_DDDPRINT("before: flags=0x%08lx, buf=%!O, loop=%!T, replacer=%!O, "
-+	                     "proplist=%!T, gap=%!O, indent=%!O, holder=%!T",
-+	                     (unsigned long) js_ctx->flags,
-+	                     (duk_heaphdr *) js_ctx->h_buf,
-+	                     (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop),
-+	                     (duk_heaphdr *) js_ctx->h_replacer,
-+	                     (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL),
-+	                     (duk_heaphdr *) js_ctx->h_gap,
-+	                     (duk_heaphdr *) js_ctx->h_indent,
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/* serialize the wrapper with empty string key */
-+
-+	duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
-+
-+	/* [ ... buf loop (proplist) (gap) holder "" ] */
-+
-+	undef = duk__enc_value1(js_ctx, idx_holder);  /* [ ... holder key ] -> [ ... holder key val ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("after: flags=0x%08lx, buf=%!O, loop=%!T, replacer=%!O, "
-+	                     "proplist=%!T, gap=%!O, indent=%!O, holder=%!T",
-+	                     (unsigned long) js_ctx->flags,
-+	                     (duk_heaphdr *) js_ctx->h_buf,
-+	                     (duk_tval *) duk_get_tval(ctx, js_ctx->idx_loop),
-+	                     (duk_heaphdr *) js_ctx->h_replacer,
-+	                     (duk_tval *) (js_ctx->idx_proplist >= 0 ? duk_get_tval(ctx, js_ctx->idx_proplist) : NULL),
-+	                     (duk_heaphdr *) js_ctx->h_gap,
-+	                     (duk_heaphdr *) js_ctx->h_indent,
-+	                     (duk_tval *) duk_get_tval(ctx, -3)));
-+
-+	if (undef) {
-+		/*
-+		 *  Result is undefined
-+		 */
-+
-+		duk_push_undefined(ctx);
-+	} else {
-+		/*
-+		 *  Finish and convert buffer to result string
-+		 */
-+
-+		duk__enc_value2(js_ctx);  /* [ ... key val ] -> [ ... ] */
-+		DUK_ASSERT(js_ctx->h_buf != NULL);
-+		duk_push_hbuffer(ctx, (duk_hbuffer *) js_ctx->h_buf);
-+		duk_to_string(ctx, -1);
-+	}
-+
-+	/* The stack has a variable shape here, so force it to the
-+	 * desired one explicitly.
-+	 */
-+
-+	duk_replace(ctx, entry_top);
-+	duk_set_top(ctx, entry_top + 1);
-+
-+	DUK_DDD(DUK_DDDPRINT("JSON stringify end: value=%!T, replacer=%!T, space=%!T, "
-+	                     "flags=0x%08lx, result=%!T, stack_top=%ld",
-+	                     (duk_tval *) duk_get_tval(ctx, idx_value),
-+	                     (duk_tval *) duk_get_tval(ctx, idx_replacer),
-+	                     (duk_tval *) duk_get_tval(ctx, idx_space),
-+	                     (unsigned long) flags,
-+	                     (duk_tval *) duk_get_tval(ctx, -1),
-+	                     (long) duk_get_top(ctx)));
-+
-+	DUK_ASSERT(duk_get_top(ctx) == entry_top + 1);
-+}
-+
-+/*
-+ *  Entry points
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_json_object_parse(duk_context *ctx) {
-+	duk_bi_json_parse_helper(ctx,
-+	                         0 /*idx_value*/,
-+	                         1 /*idx_replacer*/,
-+	                         0 /*flags*/);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_json_object_stringify(duk_context *ctx) {
-+	duk_bi_json_stringify_helper(ctx,
-+	                             0 /*idx_value*/,
-+	                             1 /*idx_replacer*/,
-+	                             2 /*idx_space*/,
-+	                             0 /*flags*/);
-+	return 1;
-+}
-+#line 1 "duk_bi_logger.c"
-+/*
-+ *  Logging support
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* 3-letter log level strings */
-+DUK_LOCAL const duk_uint8_t duk__log_level_strings[] = {
-+	(duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_C,
-+	(duk_uint8_t) DUK_ASC_UC_D, (duk_uint8_t) DUK_ASC_UC_B, (duk_uint8_t) DUK_ASC_UC_G,
-+	(duk_uint8_t) DUK_ASC_UC_I, (duk_uint8_t) DUK_ASC_UC_N, (duk_uint8_t) DUK_ASC_UC_F,
-+	(duk_uint8_t) DUK_ASC_UC_W, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_N,
-+	(duk_uint8_t) DUK_ASC_UC_E, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_R,
-+	(duk_uint8_t) DUK_ASC_UC_F, (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_L
-+};
-+
-+/* Constructor */
-+DUK_INTERNAL duk_ret_t duk_bi_logger_constructor(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t nargs;
-+
-+	/* Calling as a non-constructor is not meaningful. */
-+	if (!duk_is_constructor_call(ctx)) {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+
-+	nargs = duk_get_top(ctx);
-+	duk_set_top(ctx, 1);
-+
-+	duk_push_this(ctx);
-+
-+	/* [ name this ] */
-+
-+	if (nargs == 0) {
-+		/* Automatic defaulting of logger name from caller.  This would
-+		 * work poorly with tail calls, but constructor calls are currently
-+		 * never tail calls, so tail calls are not an issue now.
-+		 */
-+
-+		if (thr->callstack_top >= 2) {
-+			duk_activation *act_caller = thr->callstack + thr->callstack_top - 2;
-+			duk_hobject *func_caller;
-+
-+			func_caller = DUK_ACT_GET_FUNC(act_caller);
-+			if (func_caller) {
-+				/* Stripping the filename might be a good idea
-+				 * ("/foo/bar/quux.js" -> logger name "quux"),
-+				 * but now used verbatim.
-+				 */
-+				duk_push_hobject(ctx, func_caller);
-+				duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
-+				duk_replace(ctx, 0);
-+			}
-+		}
-+	}
-+	/* the stack is unbalanced here on purpose; we only rely on the
-+	 * initial two values: [ name this ].
-+	 */
-+
-+	if (duk_is_string(ctx, 0)) {
-+		duk_dup(ctx, 0);
-+		duk_put_prop_stridx(ctx, 1, DUK_STRIDX_LC_N);
-+	} else {
-+		/* don't set 'n' at all, inherited value is used as name */
-+	}
-+
-+	duk_compact(ctx, 1);
-+
-+	return 0;  /* keep default instance */
-+}
-+
-+/* Default function to format objects.  Tries to use toLogString() but falls
-+ * back to toString().  Any errors are propagated out without catching.
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_fmt(duk_context *ctx) {
-+	if (duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_LOG_STRING)) {
-+		/* [ arg toLogString ] */
-+
-+		duk_dup(ctx, 0);
-+		duk_call_method(ctx, 0);
-+
-+		/* [ arg result ] */
-+		return 1;
-+	}
-+
-+	/* [ arg undefined ] */
-+	duk_pop(ctx);
-+	duk_to_string(ctx, 0);
-+	return 1;
-+}
-+
-+/* Default function to write a formatted log line.  Writes to stderr,
-+ * appending a newline to the log line.
-+ *
-+ * The argument is a buffer whose visible size contains the log message.
-+ * This function should avoid coercing the buffer to a string to avoid
-+ * string table traffic.
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_raw(duk_context *ctx) {
-+	const char *data;
-+	duk_size_t data_len;
-+
-+	DUK_UNREF(ctx);
-+	DUK_UNREF(data);
-+	DUK_UNREF(data_len);
-+
-+#ifdef DUK_USE_FILE_IO
-+	data = (const char *) duk_require_buffer(ctx, 0, &data_len);
-+	DUK_FWRITE((const void *) data, 1, data_len, DUK_STDERR);
-+	DUK_FPUTC((int) '\n', DUK_STDERR);
-+	DUK_FFLUSH(DUK_STDERR);
-+#else
-+	/* nop */
-+#endif
-+	return 0;
-+}
-+
-+/* Log frontend shared helper, magic value indicates log level.  Provides
-+ * frontend functions: trace(), debug(), info(), warn(), error(), fatal().
-+ * This needs to have small footprint, reasonable performance, minimal
-+ * memory churn, etc.
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_double_t now;
-+	duk_small_int_t entry_lev = duk_get_current_magic(ctx);
-+	duk_small_int_t logger_lev;
-+	duk_int_t nargs;
-+	duk_int_t i;
-+	duk_size_t tot_len;
-+	const duk_uint8_t *arg_str;
-+	duk_size_t arg_len;
-+	duk_uint8_t *buf, *p;
-+	const duk_uint8_t *q;
-+	duk_uint8_t date_buf[DUK_BI_DATE_ISO8601_BUFSIZE];
-+	duk_size_t date_len;
-+	duk_small_int_t rc;
-+
-+	DUK_ASSERT(entry_lev >= 0 && entry_lev <= 5);
-+
-+	/* XXX: sanitize to printable (and maybe ASCII) */
-+	/* XXX: better multiline */
-+
-+	/*
-+	 *  Logger arguments are:
-+	 *
-+	 *    magic: log level (0-5)
-+	 *    this: logger
-+	 *    stack: plain log args
-+	 *
-+	 *  We want to minimize memory churn so a two-pass approach
-+	 *  is used: first pass formats arguments and computes final
-+	 *  string length, second pass copies strings either into a
-+	 *  pre-allocated and reused buffer (short messages) or into a
-+	 *  newly allocated fixed buffer.  If the backend function plays
-+	 *  nice, it won't coerce the buffer to a string (and thus
-+	 *  intern it).
-+	 */
-+
-+	nargs = duk_get_top(ctx);
-+
-+	/* [ arg1 ... argN this ] */
-+
-+	/*
-+	 *  Log level check
-+	 */
-+
-+	duk_push_this(ctx);
-+
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LC_L);
-+	logger_lev = (duk_small_int_t) duk_get_int(ctx, -1);
-+	if (entry_lev < logger_lev) {
-+		return 0;
-+	}
-+	/* log level could be popped but that's not necessary */
-+
-+	now = duk_bi_date_get_now(ctx);
-+	duk_bi_date_format_timeval(now, date_buf);
-+	date_len = DUK_STRLEN((const char *) date_buf);
-+
-+	duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LC_N);
-+	duk_to_string(ctx, -1);
-+	DUK_ASSERT(duk_is_string(ctx, -1));
-+
-+	/* [ arg1 ... argN this loggerLevel loggerName ] */
-+
-+	/*
-+	 *  Pass 1
-+	 */
-+
-+	/* Line format: <time> <entryLev> <loggerName>: <msg> */
-+
-+	tot_len = 0;
-+	tot_len += 3 +  /* separators: space, space, colon */
-+	           3 +  /* level string */
-+	           date_len +  /* time */
-+	           duk_get_length(ctx, -1);  /* loggerName */
-+
-+	for (i = 0; i < nargs; i++) {
-+		/* When formatting an argument to a string, errors may happen from multiple
-+		 * causes.  In general we want to catch obvious errors like a toLogString()
-+		 * throwing an error, but we don't currently try to catch every possible
-+		 * error.  In particular, internal errors (like out of memory or stack) are
-+		 * not caught.  Also, we expect Error toString() to not throw an error.
-+		 */
-+		if (duk_is_object(ctx, i)) {
-+			/* duk_pcall_prop() may itself throw an error, but we're content
-+			 * in catching the obvious errors (like toLogString() throwing an
-+			 * error).
-+			 */
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_FMT);
-+			duk_dup(ctx, i);
-+			/* [ arg1 ... argN this loggerLevel loggerName 'fmt' arg ] */
-+			/* call: this.fmt(arg) */
-+			rc = duk_pcall_prop(ctx, -5 /*obj_index*/, 1 /*nargs*/);
-+			if (rc) {
-+				/* Keep the error as the result (coercing it might fail below,
-+				 * but we don't catch that now).
-+				 */
-+				;
-+			}
-+			duk_replace(ctx, i);
-+		}
-+		(void) duk_to_lstring(ctx, i, &arg_len);
-+		tot_len++;  /* sep (even before first one) */
-+		tot_len += arg_len;
-+	}
-+
-+	/*
-+	 *  Pass 2
-+	 */
-+
-+	if (tot_len <= DUK_BI_LOGGER_SHORT_MSG_LIMIT) {
-+		duk_hbuffer_dynamic *h_buf;
-+
-+		DUK_DDD(DUK_DDDPRINT("reuse existing small log message buffer, tot_len %ld", (long) tot_len));
-+
-+		/* We can assert for all buffer properties because user code
-+		 * never has access to heap->log_buffer.
-+		 */
-+
-+		DUK_ASSERT(thr != NULL);
-+		DUK_ASSERT(thr->heap != NULL);
-+		h_buf = thr->heap->log_buffer;
-+		DUK_ASSERT(h_buf != NULL);
-+		DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) h_buf));
-+		DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(h_buf) == DUK_BI_LOGGER_SHORT_MSG_LIMIT);
-+
-+		/* Set buffer 'visible size' to actual message length and
-+		 * push it to the stack.
-+		 */
-+
-+		DUK_HBUFFER_SET_SIZE((duk_hbuffer *) h_buf, tot_len);
-+		duk_push_hbuffer(ctx, (duk_hbuffer *) h_buf);
-+		buf = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("use a one-off large log message buffer, tot_len %ld", (long) tot_len));
-+		buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len);
-+	}
-+	DUK_ASSERT(buf != NULL);
-+	p = buf;
-+
-+	DUK_MEMCPY((void *) p, (void *) date_buf, date_len);
-+	p += date_len;
-+	*p++ = (duk_uint8_t) DUK_ASC_SPACE;
-+
-+	q = duk__log_level_strings + (entry_lev * 3);
-+	DUK_MEMCPY((void *) p, (void *) q, (duk_size_t) 3);
-+	p += 3;
-+
-+	*p++ = (duk_uint8_t) DUK_ASC_SPACE;
-+
-+	arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, -2, &arg_len);
-+	DUK_MEMCPY((void *) p, (const void *) arg_str, arg_len);
-+	p += arg_len;
-+
-+	*p++ = (duk_uint8_t) DUK_ASC_COLON;
-+
-+	for (i = 0; i < nargs; i++) {
-+		*p++ = (duk_uint8_t) DUK_ASC_SPACE;
-+
-+		arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &arg_len);
-+		DUK_ASSERT(arg_str != NULL);
-+		DUK_MEMCPY((void *) p, (const void *) arg_str, arg_len);
-+		p += arg_len;
-+	}
-+	DUK_ASSERT(buf + tot_len == p);
-+
-+	/* [ arg1 ... argN this loggerLevel loggerName buffer ] */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT) && defined(DUK_USE_DEBUGGER_FWD_LOGGING)
-+	/* Do debugger forwarding before raw() because the raw() function
-+	 * doesn't get the log level right now.
-+	 */
-+	if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
-+		const char *log_buf;
-+		duk_size_t sz_buf;
-+		log_buf = (const char *) duk_get_buffer(ctx, -1, &sz_buf);
-+		DUK_ASSERT(log_buf != NULL);
-+		duk_debug_write_notify(thr, DUK_DBG_CMD_LOG);
-+		duk_debug_write_int(thr, (duk_int32_t) entry_lev);
-+		duk_debug_write_string(thr, (const char *) log_buf, sz_buf);
-+		duk_debug_write_eom(thr);
-+	}
-+#endif
-+
-+	/* Call this.raw(msg); look up through the instance allows user to override
-+	 * the raw() function in the instance or in the prototype for maximum
-+	 * flexibility.
-+	 */
-+	duk_push_hstring_stridx(ctx, DUK_STRIDX_RAW);
-+	duk_dup(ctx, -2);
-+	/* [ arg1 ... argN this loggerLevel loggerName buffer 'raw' buffer ] */
-+	duk_call_prop(ctx, -6, 1);  /* this.raw(buffer) */
-+
-+	return 0;
-+}
-+#line 1 "duk_bi_math.c"
-+/*
-+ *  Math built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#if defined(DUK_USE_MATH_BUILTIN)
-+
-+/*
-+ *  Use static helpers which can work with math.h functions matching
-+ *  the following signatures. This is not portable if any of these math
-+ *  functions is actually a macro.
-+ *
-+ *  Typing here is intentionally 'double' wherever values interact with
-+ *  the standard library APIs.
-+ */
-+
-+typedef double (*duk__one_arg_func)(double);
-+typedef double (*duk__two_arg_func)(double, double);
-+
-+DUK_LOCAL duk_ret_t duk__math_minmax(duk_context *ctx, duk_double_t initial, duk__two_arg_func min_max) {
-+	duk_idx_t n = duk_get_top(ctx);
-+	duk_idx_t i;
-+	duk_double_t res = initial;
-+	duk_double_t t;
-+
-+	/*
-+	 *  Note: fmax() does not match the E5 semantics.  E5 requires
-+	 *  that if -any- input to Math.max() is a NaN, the result is a
-+	 *  NaN.  fmax() will return a NaN only if -both- inputs are NaN.
-+	 *  Same applies to fmin().
-+	 *
-+	 *  Note: every input value must be coerced with ToNumber(), even
-+	 *  if we know the result will be a NaN anyway: ToNumber() may have
-+	 *  side effects for which even order of evaluation matters.
-+	 */
-+
-+	for (i = 0; i < n; i++) {
-+		t = duk_to_number(ctx, i);
-+		if (DUK_FPCLASSIFY(t) == DUK_FP_NAN || DUK_FPCLASSIFY(res) == DUK_FP_NAN) {
-+			/* Note: not normalized, but duk_push_number() will normalize */
-+			res = (duk_double_t) DUK_DOUBLE_NAN;
-+		} else {
-+			res = (duk_double_t) min_max(res, (double) t);
-+		}
-+	}
-+
-+	duk_push_number(ctx, res);
-+	return 1;
-+}
-+
-+DUK_LOCAL double duk__fmin_fixed(double x, double y) {
-+	/* fmin() with args -0 and +0 is not guaranteed to return
-+	 * -0 as Ecmascript requires.
-+	 */
-+	if (x == 0 && y == 0) {
-+		/* XXX: what's the safest way of creating a negative zero? */
-+		if (DUK_SIGNBIT(x) != 0 || DUK_SIGNBIT(y) != 0) {
-+			return -0.0;
-+		} else {
-+			return +0.0;
-+		}
-+	}
-+#ifdef DUK_USE_MATH_FMIN
-+	return DUK_FMIN(x, y);
-+#else
-+	return (x < y ? x : y);
-+#endif
-+}
-+
-+DUK_LOCAL double duk__fmax_fixed(double x, double y) {
-+	/* fmax() with args -0 and +0 is not guaranteed to return
-+	 * +0 as Ecmascript requires.
-+	 */
-+	if (x == 0 && y == 0) {
-+		if (DUK_SIGNBIT(x) == 0 || DUK_SIGNBIT(y) == 0) {
-+			return +0.0;
-+		} else {
-+			return -0.0;
-+		}
-+	}
-+#ifdef DUK_USE_MATH_FMAX
-+	return DUK_FMAX(x, y);
-+#else
-+	return (x > y ? x : y);
-+#endif
-+}
-+
-+DUK_LOCAL double duk__round_fixed(double x) {
-+	/* Numbers half-way between integers must be rounded towards +Infinity,
-+	 * e.g. -3.5 must be rounded to -3 (not -4).  When rounded to zero, zero
-+	 * sign must be set appropriately.  E5.1 Section 15.8.2.15.
-+	 *
-+	 * Note that ANSI C round() is "round to nearest integer, away from zero",
-+	 * which is incorrect for negative values.  Here we make do with floor().
-+	 */
-+
-+	duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
-+	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE || c == DUK_FP_ZERO) {
-+		return x;
-+	}
-+
-+	/*
-+	 *  x is finite and non-zero
-+	 *
-+	 *  -1.6 -> floor(-1.1) -> -2
-+	 *  -1.5 -> floor(-1.0) -> -1  (towards +Inf)
-+	 *  -1.4 -> floor(-0.9) -> -1
-+	 *  -0.5 -> -0.0               (special case)
-+	 *  -0.1 -> -0.0               (special case)
-+	 *  +0.1 -> +0.0               (special case)
-+	 *  +0.5 -> floor(+1.0) -> 1   (towards +Inf)
-+	 *  +1.4 -> floor(+1.9) -> 1
-+	 *  +1.5 -> floor(+2.0) -> 2   (towards +Inf)
-+	 *  +1.6 -> floor(+2.1) -> 2
-+	 */
-+
-+	if (x >= -0.5 && x < 0.5) {
-+		/* +0.5 is handled by floor, this is on purpose */
-+		if (x < 0.0) {
-+			return -0.0;
-+		} else {
-+			return +0.0;
-+		}
-+	}
-+
-+	return DUK_FLOOR(x + 0.5);
-+}
-+
-+DUK_LOCAL double duk__pow_fixed(double x, double y) {
-+	/* The ANSI C pow() semantics differ from Ecmascript.
-+	 *
-+	 * E.g. when x==1 and y is +/- infinite, the Ecmascript required
-+	 * result is NaN, while at least Linux pow() returns 1.
-+	 */
-+
-+	duk_small_int_t cx, cy, sx;
-+
-+	DUK_UNREF(cx);
-+	DUK_UNREF(sx);
-+	cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
-+
-+	if (cy == DUK_FP_NAN) {
-+		goto ret_nan;
-+	}
-+	if (DUK_FABS(x) == 1.0 && cy == DUK_FP_INFINITE) {
-+		goto ret_nan;
-+	}
-+#if defined(DUK_USE_POW_NETBSD_WORKAROUND)
-+	/* See test-bug-netbsd-math-pow.js: NetBSD 6.0 on x86 (at least) does not
-+	 * correctly handle some cases where x=+/-0.  Specific fixes to these
-+	 * here.
-+	 */
-+	cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
-+	if (cx == DUK_FP_ZERO && y < 0.0) {
-+		sx = (duk_small_int_t) DUK_SIGNBIT(x);
-+		if (sx == 0) {
-+			/* Math.pow(+0,y) should be Infinity when y<0.  NetBSD pow()
-+			 * returns -Infinity instead when y is <0 and finite.  The
-+			 * if-clause also catches y == -Infinity (which works even
-+			 * without the fix).
-+			 */
-+			return DUK_DOUBLE_INFINITY;
-+		} else {
-+			/* Math.pow(-0,y) where y<0 should be:
-+			 *   - -Infinity if y<0 and an odd integer
-+			 *   - Infinity otherwise
-+			 * NetBSD pow() returns -Infinity for all finite y<0.  The
-+			 * if-clause also catches y == -Infinity (which works even
-+			 * without the fix).
-+			 */
-+
-+			/* fmod() return value has same sign as input (negative) so
-+			 * the result here will be in the range ]-2,0], 1 indicates
-+			 * odd.  If x is -Infinity, NaN is returned and the odd check
-+			 * always concludes "not odd" which results in desired outcome.
-+			 */
-+			double tmp = DUK_FMOD(y, 2);
-+			if (tmp == -1.0) {
-+				return -DUK_DOUBLE_INFINITY;
-+			} else {
-+				/* Not odd, or y == -Infinity */
-+				return DUK_DOUBLE_INFINITY;
-+			}
-+		}
-+	}
-+#endif
-+	return DUK_POW(x, y);
-+
-+ ret_nan:
-+	return DUK_DOUBLE_NAN;
-+}
-+
-+/* Wrappers for calling standard math library methods.  These may be required
-+ * on platforms where one or more of the math built-ins are defined as macros
-+ * or inline functions and are thus not suitable to be used as function pointers.
-+ */
-+#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
-+DUK_LOCAL double duk__fabs(double x) {
-+	return DUK_FABS(x);
-+}
-+DUK_LOCAL double duk__acos(double x) {
-+	return DUK_ACOS(x);
-+}
-+DUK_LOCAL double duk__asin(double x) {
-+	return DUK_ASIN(x);
-+}
-+DUK_LOCAL double duk__atan(double x) {
-+	return DUK_ATAN(x);
-+}
-+DUK_LOCAL double duk__ceil(double x) {
-+	return DUK_CEIL(x);
-+}
-+DUK_LOCAL double duk__cos(double x) {
-+	return DUK_COS(x);
-+}
-+DUK_LOCAL double duk__exp(double x) {
-+	return DUK_EXP(x);
-+}
-+DUK_LOCAL double duk__floor(double x) {
-+	return DUK_FLOOR(x);
-+}
-+DUK_LOCAL double duk__log(double x) {
-+	return DUK_LOG(x);
-+}
-+DUK_LOCAL double duk__sin(double x) {
-+	return DUK_SIN(x);
-+}
-+DUK_LOCAL double duk__sqrt(double x) {
-+	return DUK_SQRT(x);
-+}
-+DUK_LOCAL double duk__tan(double x) {
-+	return DUK_TAN(x);
-+}
-+DUK_LOCAL double duk__atan2(double x, double y) {
-+	return DUK_ATAN2(x, y);
-+}
-+#endif  /* DUK_USE_AVOID_PLATFORM_FUNCPTRS */
-+
-+/* order must match constants in genbuiltins.py */
-+DUK_LOCAL const duk__one_arg_func duk__one_arg_funcs[] = {
-+#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
-+	duk__fabs,
-+	duk__acos,
-+	duk__asin,
-+	duk__atan,
-+	duk__ceil,
-+	duk__cos,
-+	duk__exp,
-+	duk__floor,
-+	duk__log,
-+	duk__round_fixed,
-+	duk__sin,
-+	duk__sqrt,
-+	duk__tan
-+#else
-+	DUK_FABS,
-+	DUK_ACOS,
-+	DUK_ASIN,
-+	DUK_ATAN,
-+	DUK_CEIL,
-+	DUK_COS,
-+	DUK_EXP,
-+	DUK_FLOOR,
-+	DUK_LOG,
-+	duk__round_fixed,
-+	DUK_SIN,
-+	DUK_SQRT,
-+	DUK_TAN
-+#endif
-+};
-+
-+/* order must match constants in genbuiltins.py */
-+DUK_LOCAL const duk__two_arg_func duk__two_arg_funcs[] = {
-+#if defined(DUK_USE_AVOID_PLATFORM_FUNCPTRS)
-+	duk__atan2,
-+	duk__pow_fixed
-+#else
-+	DUK_ATAN2,
-+	duk__pow_fixed
-+#endif
-+};
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx) {
-+	duk_small_int_t fun_idx = duk_get_current_magic(ctx);
-+	duk__one_arg_func fun;
-+
-+	DUK_ASSERT(fun_idx >= 0);
-+	DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__one_arg_funcs) / sizeof(duk__one_arg_func)));
-+	fun = duk__one_arg_funcs[fun_idx];
-+	duk_push_number(ctx, (duk_double_t) fun((double) duk_to_number(ctx, 0)));
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx) {
-+	duk_small_int_t fun_idx = duk_get_current_magic(ctx);
-+	duk__two_arg_func fun;
-+
-+	DUK_ASSERT(fun_idx >= 0);
-+	DUK_ASSERT(fun_idx < (duk_small_int_t) (sizeof(duk__two_arg_funcs) / sizeof(duk__two_arg_func)));
-+	fun = duk__two_arg_funcs[fun_idx];
-+	duk_push_number(ctx, (duk_double_t) fun((double) duk_to_number(ctx, 0), (double) duk_to_number(ctx, 1)));
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_max(duk_context *ctx) {
-+	return duk__math_minmax(ctx, -DUK_DOUBLE_INFINITY, duk__fmax_fixed);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_min(duk_context *ctx) {
-+	return duk__math_minmax(ctx, DUK_DOUBLE_INFINITY, duk__fmin_fixed);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_random(duk_context *ctx) {
-+	duk_push_number(ctx, (duk_double_t) duk_util_tinyrandom_get_double((duk_hthread *) ctx));
-+	return 1;
-+}
-+
-+#else  /* DUK_USE_MATH_BUILTIN */
-+
-+/* A stubbed built-in is useful for e.g. compilation torture testing with BCC. */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_onearg_shared(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNIMPLEMENTED_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_twoarg_shared(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNIMPLEMENTED_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_max(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNIMPLEMENTED_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_min(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNIMPLEMENTED_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_math_object_random(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNIMPLEMENTED_ERROR;
-+}
-+
-+#endif  /* DUK_USE_MATH_BUILTIN */
-+#line 1 "duk_bi_number.c"
-+/*
-+ *  Number built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_LOCAL duk_double_t duk__push_this_number_plain(duk_context *ctx) {
-+	duk_hobject *h;
-+
-+	/* Number built-in accepts a plain number or a Number object (whose
-+	 * internal value is operated on).  Other types cause TypeError.
-+	 */
-+
-+	duk_push_this(ctx);
-+	if (duk_is_number(ctx, -1)) {
-+		DUK_DDD(DUK_DDDPRINT("plain number value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+		goto done;
-+	}
-+	h = duk_get_hobject(ctx, -1);
-+	if (!h ||
-+	    (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_NUMBER)) {
-+		DUK_DDD(DUK_DDDPRINT("unacceptable this value: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+		DUK_ERROR((duk_hthread *) ctx, DUK_ERR_TYPE_ERROR, "expected a number");
-+	}
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-+	DUK_ASSERT(duk_is_number(ctx, -1));
-+	DUK_DDD(DUK_DDDPRINT("number object: %!T, internal value: %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
-+	duk_remove(ctx, -2);
-+
-+ done:
-+	return duk_get_number(ctx, -1);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_number_constructor(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t nargs;
-+	duk_hobject *h_this;
-+
-+	DUK_UNREF(thr);
-+
-+	/*
-+	 *  The Number constructor uses ToNumber(arg) for number coercion
-+	 *  (coercing an undefined argument to NaN).  However, if the
-+	 *  argument is not given at all, +0 must be used instead.  To do
-+	 *  this, a vararg function is used.
-+	 */
-+
-+	nargs = duk_get_top(ctx);
-+	if (nargs == 0) {
-+		duk_push_int(ctx, 0);
-+	}
-+	duk_to_number(ctx, 0);
-+	duk_set_top(ctx, 1);
-+	DUK_ASSERT_TOP(ctx, 1);
-+
-+	if (!duk_is_constructor_call(ctx)) {
-+		return 1;
-+	}
-+
-+	/*
-+	 *  E5 Section 15.7.2.1 requires that the constructed object
-+	 *  must have the original Number.prototype as its internal
-+	 *  prototype.  However, since Number.prototype is non-writable
-+	 *  and non-configurable, this doesn't have to be enforced here:
-+	 *  The default object (bound to 'this') is OK, though we have
-+	 *  to change its class.
-+	 *
-+	 *  Internal value set to ToNumber(arg) or +0; if no arg given,
-+	 *  ToNumber(undefined) = NaN, so special treatment is needed
-+	 *  (above).  String internal value is immutable.
-+	 */
-+
-+	/* XXX: helper */
-+	duk_push_this(ctx);
-+	h_this = duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(h_this != NULL);
-+	DUK_HOBJECT_SET_CLASS_NUMBER(h_this, DUK_HOBJECT_CLASS_NUMBER);
-+
-+	DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_this) == thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE]);
-+	DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_this) == DUK_HOBJECT_CLASS_NUMBER);
-+	DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h_this));
-+
-+	duk_dup(ctx, 0);  /* -> [ val obj val ] */
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
-+	return 0;  /* no return value -> don't replace created value */
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_number_prototype_value_of(duk_context *ctx) {
-+	(void) duk__push_this_number_plain(ctx);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_string(duk_context *ctx) {
-+	duk_small_int_t radix;
-+	duk_small_uint_t n2s_flags;
-+
-+	(void) duk__push_this_number_plain(ctx);
-+	if (duk_is_undefined(ctx, 0)) {
-+		radix = 10;
-+	} else {
-+		radix = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 2, 36);
-+	}
-+	DUK_DDD(DUK_DDDPRINT("radix=%ld", (long) radix));
-+
-+	n2s_flags = 0;
-+
-+	duk_numconv_stringify(ctx,
-+	                      radix /*radix*/,
-+	                      0 /*digits*/,
-+	                      n2s_flags /*flags*/);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_locale_string(duk_context *ctx) {
-+	/* XXX: just use toString() for now; permitted although not recommended.
-+	 * nargs==1, so radix is passed to toString().
-+	 */
-+	return duk_bi_number_prototype_to_string(ctx);
-+}
-+
-+/*
-+ *  toFixed(), toExponential(), toPrecision()
-+ */
-+
-+/* XXX: shared helper for toFixed(), toExponential(), toPrecision()? */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_fixed(duk_context *ctx) {
-+	duk_small_int_t frac_digits;
-+	duk_double_t d;
-+	duk_small_int_t c;
-+	duk_small_uint_t n2s_flags;
-+
-+	frac_digits = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 0, 20);
-+	d = duk__push_this_number_plain(ctx);
-+
-+	c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-+	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
-+		goto use_to_string;
-+	}
-+
-+	if (d >= 1.0e21 || d <= -1.0e21) {
-+		goto use_to_string;
-+	}
-+
-+	n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT |
-+	            DUK_N2S_FLAG_FRACTION_DIGITS;
-+
-+	duk_numconv_stringify(ctx,
-+	                      10 /*radix*/,
-+	                      frac_digits /*digits*/,
-+	                      n2s_flags /*flags*/);
-+	return 1;
-+
-+ use_to_string:
-+	DUK_ASSERT_TOP(ctx, 2);
-+	duk_to_string(ctx, -1);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_exponential(duk_context *ctx) {
-+	duk_bool_t frac_undefined;
-+	duk_small_int_t frac_digits;
-+	duk_double_t d;
-+	duk_small_int_t c;
-+	duk_small_uint_t n2s_flags;
-+
-+	d = duk__push_this_number_plain(ctx);
-+
-+	frac_undefined = duk_is_undefined(ctx, 0);
-+	duk_to_int(ctx, 0);  /* for side effects */
-+
-+	c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-+	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
-+		goto use_to_string;
-+	}
-+
-+	frac_digits = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 0, 20);
-+
-+	n2s_flags = DUK_N2S_FLAG_FORCE_EXP |
-+	           (frac_undefined ? 0 : DUK_N2S_FLAG_FIXED_FORMAT);
-+
-+	duk_numconv_stringify(ctx,
-+	                      10 /*radix*/,
-+	                      frac_digits + 1 /*leading digit + fractions*/,
-+	                      n2s_flags /*flags*/);
-+	return 1;
-+
-+ use_to_string:
-+	DUK_ASSERT_TOP(ctx, 2);
-+	duk_to_string(ctx, -1);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_number_prototype_to_precision(duk_context *ctx) {
-+	/* The specification has quite awkward order of coercion and
-+	 * checks for toPrecision().  The operations below are a bit
-+	 * reordered, within constraints of observable side effects.
-+	 */
-+
-+	duk_double_t d;
-+	duk_small_int_t prec;
-+	duk_small_int_t c;
-+	duk_small_uint_t n2s_flags;
-+
-+	DUK_ASSERT_TOP(ctx, 1);
-+
-+	d = duk__push_this_number_plain(ctx);
-+	if (duk_is_undefined(ctx, 0)) {
-+		goto use_to_string;
-+	}
-+	DUK_ASSERT_TOP(ctx, 2);
-+
-+	duk_to_int(ctx, 0);  /* for side effects */
-+
-+	c = (duk_small_int_t) DUK_FPCLASSIFY(d);
-+	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
-+		goto use_to_string;
-+	}
-+
-+	prec = (duk_small_int_t) duk_to_int_check_range(ctx, 0, 1, 21);
-+
-+	n2s_flags = DUK_N2S_FLAG_FIXED_FORMAT |
-+	            DUK_N2S_FLAG_NO_ZERO_PAD;
-+
-+	duk_numconv_stringify(ctx,
-+	                      10 /*radix*/,
-+	                      prec /*digits*/,
-+	                      n2s_flags /*flags*/);
-+	return 1;
-+
-+ use_to_string:
-+	/* Used when precision is undefined; also used for NaN (-> "NaN"),
-+	 * and +/- infinity (-> "Infinity", "-Infinity").
-+	 */
-+
-+	DUK_ASSERT_TOP(ctx, 2);
-+	duk_to_string(ctx, -1);
-+	return 1;
-+}
-+#line 1 "duk_bi_object.c"
-+/*
-+ *  Object built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor(duk_context *ctx) {
-+	if (!duk_is_constructor_call(ctx) &&
-+	    !duk_is_null_or_undefined(ctx, 0)) {
-+		duk_to_object(ctx, 0);
-+		return 1;
-+	}
-+
-+	if (duk_is_object(ctx, 0)) {
-+		return 1;
-+	}
-+
-+	/* Pointer and buffer primitive values are treated like other
-+	 * primitives values which have a fully fledged object counterpart:
-+	 * promote to an object value.  Lightfuncs are coerced with
-+	 * ToObject() even they could also be returned as is.
-+	 */
-+	if (duk_check_type_mask(ctx, 0, DUK_TYPE_MASK_STRING |
-+	                                DUK_TYPE_MASK_BOOLEAN |
-+	                                DUK_TYPE_MASK_NUMBER |
-+	                                DUK_TYPE_MASK_POINTER |
-+	                                DUK_TYPE_MASK_BUFFER |
-+	                                DUK_TYPE_MASK_LIGHTFUNC)) {
-+		duk_to_object(ctx, 0);
-+		return 1;
-+	}
-+
-+	duk_push_object_helper(ctx,
-+	                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-+	                       DUK_BIDX_OBJECT_PROTOTYPE);
-+	return 1;
-+}
-+
-+/* Shared helper to implement Object.getPrototypeOf and the ES6
-+ * Object.prototype.__proto__ getter.
-+ *
-+ * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-get-object.prototype.__proto__
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_object_getprototype_shared(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h;
-+	duk_hobject *proto;
-+
-+	DUK_UNREF(thr);
-+
-+	/* magic: 0=getter call, 1=Object.getPrototypeOf */
-+	if (duk_get_current_magic(ctx) == 0) {
-+		duk_push_this_coercible_to_object(ctx);
-+		duk_insert(ctx, 0);
-+	}
-+
-+	h = duk_require_hobject_or_lfunc(ctx, 0);
-+	/* h is NULL for lightfunc */
-+
-+	/* XXX: should the API call handle this directly, i.e. attempt
-+	 * to duk_push_hobject(ctx, null) would push a null instead?
-+	 * (On the other hand 'undefined' would be just as logical, but
-+	 * not wanted here.)
-+	 */
-+
-+	if (h == NULL) {
-+		duk_push_hobject_bidx(ctx, DUK_BIDX_FUNCTION_PROTOTYPE);
-+	} else {
-+		proto = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
-+		if (proto) {
-+			duk_push_hobject(ctx, proto);
-+		} else {
-+			duk_push_null(ctx);
-+		}
-+	}
-+	return 1;
-+}
-+
-+/* Shared helper to implement ES6 Object.setPrototypeOf and
-+ * Object.prototype.__proto__ setter.
-+ *
-+ * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-get-object.prototype.__proto__
-+ * https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.setprototypeof
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_object_setprototype_shared(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h_obj;
-+	duk_hobject *h_new_proto;
-+	duk_hobject *h_curr;
-+	duk_ret_t ret_success = 1;  /* retval for success path */
-+
-+	/* Preliminaries for __proto__ and setPrototypeOf (E6 19.1.2.18 steps 1-4);
-+	 * magic: 0=setter call, 1=Object.setPrototypeOf
-+	 */
-+	if (duk_get_current_magic(ctx) == 0) {
-+		duk_push_this_check_object_coercible(ctx);
-+		duk_insert(ctx, 0);
-+		if (!duk_check_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT)) {
-+			return 0;
-+		}
-+
-+		/* __proto__ setter returns 'undefined' on success unlike the
-+		 * setPrototypeOf() call which returns the target object.
-+		 */
-+		ret_success = 0;
-+	} else {
-+		duk_require_object_coercible(ctx, 0);
-+		duk_require_type_mask(ctx, 1, DUK_TYPE_MASK_NULL | DUK_TYPE_MASK_OBJECT);
-+	}
-+
-+	h_new_proto = duk_get_hobject(ctx, 1);
-+	/* h_new_proto may be NULL */
-+	if (duk_is_lightfunc(ctx, 0)) {
-+		if (h_new_proto == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]) {
-+			goto skip;
-+		}
-+		goto fail_nonextensible;
-+	}
-+	h_obj = duk_get_hobject(ctx, 0);
-+	if (!h_obj) {
-+		goto skip;
-+	}
-+	DUK_ASSERT(h_obj != NULL);
-+
-+	/* [[SetPrototypeOf]] standard behavior, E6 9.1.2 */
-+	/* NOTE: steps 7-8 seem to be a cut-paste bug in the E6 draft */
-+	/* TODO: implement Proxy object support here */
-+
-+	if (h_new_proto == DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_obj)) {
-+		goto skip;
-+	}
-+	if (!DUK_HOBJECT_HAS_EXTENSIBLE(h_obj)) {
-+		goto fail_nonextensible;
-+	}
-+	for (h_curr = h_new_proto; h_curr != NULL; h_curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_curr)) {
-+		/* Loop prevention */
-+		if (h_curr == h_obj) {
-+			goto fail_loop;
-+		}
-+	}
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h_obj, h_new_proto);
-+	/* fall thru */
-+
-+ skip:
-+	duk_set_top(ctx, 1);
-+	return ret_success;
-+
-+ fail_nonextensible:
-+ fail_loop:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_get_own_property_descriptor(duk_context *ctx) {
-+	/* XXX: no need for indirect call */
-+	return duk_hobject_object_get_own_property_descriptor(ctx);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_create(duk_context *ctx) {
-+	duk_tval *tv;
-+	duk_hobject *proto = NULL;
-+
-+	DUK_ASSERT_TOP(ctx, 2);
-+
-+	tv = duk_get_tval(ctx, 0);
-+	DUK_ASSERT(tv != NULL);
-+	if (DUK_TVAL_IS_NULL(tv)) {
-+		;
-+	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-+		proto = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(proto != NULL);
-+	} else {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+
-+	(void) duk_push_object_helper_proto(ctx,
-+	                                    DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-+	                                    proto);
-+
-+	if (!duk_is_undefined(ctx, 1)) {
-+		/* [ O Properties obj ] */
-+
-+		duk_replace(ctx, 0);
-+
-+		/* [ obj Properties ] */
-+
-+		/* Just call the "original" Object.defineProperties() to
-+		 * finish up.
-+		 */
-+
-+		return duk_bi_object_constructor_define_properties(ctx);
-+	}
-+
-+	/* [ O Properties obj ] */
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_property(duk_context *ctx) {
-+	duk_hobject *obj;
-+	duk_hstring *key;
-+	duk_hobject *get;
-+	duk_hobject *set;
-+	duk_idx_t idx_value;
-+	duk_uint_t defprop_flags;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	DUK_DDD(DUK_DDDPRINT("Object.defineProperty(): ctx=%p obj=%!T key=%!T desc=%!T",
-+	                     (void *) ctx,
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 1),
-+	                     (duk_tval *) duk_get_tval(ctx, 2)));
-+
-+	/* [ obj key desc ] */
-+
-+	/* Lightfuncs are currently supported by coercing to a temporary
-+	 * Function object; changes will be allowed (the coerced value is
-+	 * extensible) but will be lost.
-+	 */
-+	obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-+	(void) duk_to_string(ctx, 1);
-+	key = duk_require_hstring(ctx, 1);
-+	(void) duk_require_hobject(ctx, 2);
-+
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(duk_get_hobject(ctx, 2) != NULL);
-+
-+	/*
-+	 *  Validate and convert argument property descriptor (an Ecmascript
-+	 *  object) into a set of defprop_flags and possibly property value,
-+	 *  getter, and/or setter values on the value stack.
-+	 *
-+	 *  Lightfunc set/get values are coerced to full Functions.
-+	 */
-+
-+	duk_hobject_prepare_property_descriptor(ctx,
-+	                                        2 /*idx_desc*/,
-+	                                        &defprop_flags,
-+	                                        &idx_value,
-+	                                        &get,
-+	                                        &set);
-+
-+	/*
-+	 *  Use Object.defineProperty() helper for the actual operation.
-+	 */
-+
-+	duk_hobject_define_property_helper(ctx,
-+	                                   defprop_flags,
-+	                                   obj,
-+	                                   key,
-+	                                   idx_value,
-+	                                   get,
-+	                                   set);
-+
-+	/* Ignore the normalize/validate helper outputs on the value stack,
-+	 * they're popped automatically.
-+	 */
-+
-+	/*
-+	 *  Return target object.
-+	 */
-+
-+	duk_push_hobject(ctx, obj);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_define_properties(duk_context *ctx) {
-+	duk_small_uint_t pass;
-+	duk_uint_t defprop_flags;
-+	duk_hobject *obj;
-+	duk_idx_t idx_value;
-+	duk_hobject *get;
-+	duk_hobject *set;
-+
-+	/* Lightfunc handling by ToObject() coercion. */
-+	obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);  /* target */
-+	DUK_ASSERT(obj != NULL);
-+
-+	duk_to_object(ctx, 1);        /* properties object */
-+
-+	DUK_DDD(DUK_DDDPRINT("target=%!iT, properties=%!iT",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 1)));
-+
-+	/*
-+	 *  Two pass approach to processing the property descriptors.
-+	 *  On first pass validate and normalize all descriptors before
-+	 *  any changes are made to the target object.  On second pass
-+	 *  make the actual modifications to the target object.
-+	 *
-+	 *  Right now we'll just use the same normalize/validate helper
-+	 *  on both passes, ignoring its outputs on the first pass.
-+	 */
-+
-+	for (pass = 0; pass < 2; pass++) {
-+		duk_set_top(ctx, 2);  /* -> [ hobject props ] */
-+		duk_enum(ctx, 1, DUK_ENUM_OWN_PROPERTIES_ONLY /*enum_flags*/);
-+
-+		for (;;) {
-+			duk_hstring *key;
-+
-+			/* [ hobject props enum(props) ] */
-+
-+			duk_set_top(ctx, 3);
-+
-+			if (!duk_next(ctx, 2, 1 /*get_value*/)) {
-+				break;
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("-> key=%!iT, desc=%!iT",
-+			                     (duk_tval *) duk_get_tval(ctx, -2),
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+			/* [ hobject props enum(props) key desc ] */
-+
-+			duk_hobject_prepare_property_descriptor(ctx,
-+			                                        4 /*idx_desc*/,
-+			                                        &defprop_flags,
-+			                                        &idx_value,
-+			                                        &get,
-+			                                        &set);
-+
-+			/* [ hobject props enum(props) key desc value? getter? setter? ] */
-+
-+			if (pass == 0) {
-+				continue;
-+			}
-+
-+			key = duk_get_hstring(ctx, 3);
-+			DUK_ASSERT(key != NULL);
-+
-+			duk_hobject_define_property_helper(ctx,
-+			                                   defprop_flags,
-+			                                   obj,
-+			                                   key,
-+			                                   idx_value,
-+			                                   get,
-+			                                   set);
-+		}
-+	}
-+
-+	/*
-+	 *  Return target object
-+	 */
-+
-+	duk_dup(ctx, 0);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_seal_freeze_shared(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h;
-+	duk_bool_t is_freeze;
-+
-+	h = duk_require_hobject_or_lfunc(ctx, 0);
-+	if (!h) {
-+		/* Lightfunc, always success. */
-+		return 1;
-+	}
-+
-+	is_freeze = (duk_bool_t) duk_get_current_magic(ctx);
-+	duk_hobject_object_seal_freeze_helper(thr, h, is_freeze);
-+
-+	/* Sealed and frozen objects cannot gain any more properties,
-+	 * so this is a good time to compact them.
-+	 */
-+	duk_hobject_compact_props(thr, h);
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_prevent_extensions(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h;
-+
-+	h = duk_require_hobject_or_lfunc(ctx, 0);
-+	if (!h) {
-+		/* Lightfunc, always success. */
-+		return 1;
-+	}
-+	DUK_ASSERT(h != NULL);
-+
-+	DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
-+
-+	/* A non-extensible object cannot gain any more properties,
-+	 * so this is a good time to compact.
-+	 */
-+	duk_hobject_compact_props(thr, h);
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_sealed_frozen_shared(duk_context *ctx) {
-+	duk_hobject *h;
-+	duk_bool_t is_frozen;
-+	duk_bool_t rc;
-+
-+	h = duk_require_hobject_or_lfunc(ctx, 0);
-+	if (!h) {
-+		duk_push_true(ctx);  /* frozen and sealed */
-+	} else {
-+		is_frozen = duk_get_current_magic(ctx);
-+		rc = duk_hobject_object_is_sealed_frozen_helper((duk_hthread *) ctx, h, is_frozen /*is_frozen*/);
-+		duk_push_boolean(ctx, rc);
-+	}
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_is_extensible(duk_context *ctx) {
-+	duk_hobject *h;
-+
-+	h = duk_require_hobject_or_lfunc(ctx, 0);
-+	if (!h) {
-+		duk_push_false(ctx);
-+	} else {
-+		duk_push_boolean(ctx, DUK_HOBJECT_HAS_EXTENSIBLE(h));
-+	}
-+	return 1;
-+}
-+
-+/* Shared helper for Object.getOwnPropertyNames() and Object.keys().
-+ * Magic: 0=getOwnPropertyNames, 1=Object.keys.
-+ */
-+DUK_INTERNAL duk_ret_t duk_bi_object_constructor_keys_shared(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+#if defined(DUK_USE_ES6_PROXY)
-+	duk_hobject *h_proxy_target;
-+	duk_hobject *h_proxy_handler;
-+	duk_hobject *h_trap_result;
-+	duk_uarridx_t i, len, idx;
-+#endif
-+	duk_small_uint_t enum_flags;
-+
-+	DUK_ASSERT_TOP(ctx, 1);
-+	DUK_UNREF(thr);
-+
-+	obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_UNREF(obj);
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+	if (DUK_LIKELY(!duk_hobject_proxy_check(thr,
-+	                                        obj,
-+	                                        &h_proxy_target,
-+	                                        &h_proxy_handler))) {
-+		goto skip_proxy;
-+	}
-+
-+	duk_push_hobject(ctx, h_proxy_handler);
-+	if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_OWN_KEYS)) {
-+		/* Careful with reachability here: don't pop 'obj' before pushing
-+		 * proxy target.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("no ownKeys trap, get keys of target instead"));
-+		duk_pop_2(ctx);
-+		duk_push_hobject(ctx, h_proxy_target);
-+		duk_replace(ctx, 0);
-+		DUK_ASSERT_TOP(ctx, 1);
-+		goto skip_proxy;
-+	}
-+
-+	/* [ obj handler trap ] */
-+	duk_insert(ctx, -2);
-+	duk_push_hobject(ctx, h_proxy_target);  /* -> [ obj trap handler target ] */
-+	duk_call_method(ctx, 1 /*nargs*/);      /* -> [ obj trap_result ] */
-+	h_trap_result = duk_require_hobject(ctx, -1);
-+	DUK_UNREF(h_trap_result);
-+
-+	len = (duk_uarridx_t) duk_get_length(ctx, -1);
-+	idx = 0;
-+	duk_push_array(ctx);
-+	for (i = 0; i < len; i++) {
-+		/* [ obj trap_result res_arr ] */
-+		if (duk_get_prop_index(ctx, -2, i) && duk_is_string(ctx, -1)) {
-+			/* XXX: for Object.keys() we should check enumerability of key */
-+			/* [ obj trap_result res_arr propname ] */
-+			duk_put_prop_index(ctx, -2, idx);
-+			idx++;
-+		} else {
-+			duk_pop(ctx);
-+		}
-+	}
-+
-+	/* XXX: for Object.keys() the [[OwnPropertyKeys]] result (trap result)
-+	 * should be filtered so that only enumerable keys remain.  Enumerability
-+	 * should be checked with [[GetOwnProperty]] on the original object
-+	 * (i.e., the proxy in this case).  If the proxy has a getOwnPropertyDescriptor
-+	 * trap, it should be triggered for every property.  If the proxy doesn't have
-+	 * the trap, enumerability should be checked against the target object instead.
-+	 * We don't do any of this now, so Object.keys() and Object.getOwnPropertyNames()
-+	 * return the same result now for proxy traps.  We still do clean up the trap
-+	 * result, so that Object.keys() and Object.getOwnPropertyNames() will return a
-+	 * clean array of strings without gaps.
-+	 */
-+	return 1;
-+
-+ skip_proxy:
-+#endif  /* DUK_USE_ES6_PROXY */
-+
-+	DUK_ASSERT_TOP(ctx, 1);
-+
-+	if (duk_get_current_magic(ctx)) {
-+		/* Object.keys */
-+		enum_flags = DUK_ENUM_OWN_PROPERTIES_ONLY |
-+		             DUK_ENUM_NO_PROXY_BEHAVIOR;
-+	} else {
-+		/* Object.getOwnPropertyNames */
-+		enum_flags = DUK_ENUM_INCLUDE_NONENUMERABLE |
-+		             DUK_ENUM_OWN_PROPERTIES_ONLY |
-+		             DUK_ENUM_NO_PROXY_BEHAVIOR;
-+	}
-+
-+	return duk_hobject_get_enumerated_keys(ctx, enum_flags);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_string(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	duk_push_this(ctx);
-+	duk_push_string(ctx, "[object ");
-+
-+	if (duk_is_undefined(ctx, -2)) {
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_UNDEFINED);
-+	} else if (duk_is_null(ctx, -2)) {
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_UC_NULL);
-+	} else {
-+		duk_hobject *h_this;
-+		duk_hstring *h_classname;
-+
-+		duk_to_object(ctx, -2);
-+		h_this = duk_get_hobject(ctx, -2);
-+		DUK_ASSERT(h_this != NULL);
-+
-+		h_classname = DUK_HOBJECT_GET_CLASS_STRING(thr->heap, h_this);
-+		DUK_ASSERT(h_classname != NULL);
-+
-+		duk_push_hstring(ctx, h_classname);
-+	}
-+
-+	duk_push_string(ctx, "]");
-+	duk_concat(ctx, 3);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_prototype_to_locale_string(duk_context *ctx) {
-+	DUK_ASSERT_TOP(ctx, 0);
-+	(void) duk_push_this_coercible_to_object(ctx);
-+	duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_STRING);
-+	if (!duk_is_callable(ctx, 1)) {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+	duk_dup(ctx, 0);  /* -> [ O toString O ] */
-+	duk_call_method(ctx, 0);  /* XXX: call method tailcall? */
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_prototype_value_of(duk_context *ctx) {
-+	(void) duk_push_this_coercible_to_object(ctx);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_prototype_is_prototype_of(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h_v;
-+	duk_hobject *h_obj;
-+
-+	DUK_ASSERT_TOP(ctx, 1);
-+
-+	h_v = duk_get_hobject(ctx, 0);
-+	if (!h_v) {
-+		duk_push_false(ctx);  /* XXX: tail call: return duk_push_false(ctx) */
-+		return 1;
-+	}
-+
-+	h_obj = duk_push_this_coercible_to_object(ctx);
-+	DUK_ASSERT(h_obj != NULL);
-+
-+	/* E5.1 Section 15.2.4.6, step 3.a, lookup proto once before compare.
-+	 * Prototype loops should cause an error to be thrown.
-+	 */
-+	duk_push_boolean(ctx, duk_hobject_prototype_chain_contains(thr, DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h_v), h_obj, 0 /*ignore_loop*/));
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_prototype_has_own_property(duk_context *ctx) {
-+	return duk_hobject_object_ownprop_helper(ctx, 0 /*required_desc_flags*/);
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_object_prototype_property_is_enumerable(duk_context *ctx) {
-+	return duk_hobject_object_ownprop_helper(ctx, DUK_PROPDESC_FLAG_ENUMERABLE /*required_desc_flags*/);
-+}
-+#line 1 "duk_bi_pointer.c"
-+/*
-+ *  Pointer built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Constructor
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_pointer_constructor(duk_context *ctx) {
-+	/* XXX: this behavior is quite useless now; it would be nice to be able
-+	 * to create pointer values from e.g. numbers or strings.  Numbers are
-+	 * problematic on 64-bit platforms though.  Hex encoded strings?
-+	 */
-+	if (duk_get_top(ctx) == 0) {
-+		duk_push_pointer(ctx, NULL);
-+	} else {
-+		duk_to_pointer(ctx, 0);
-+	}
-+	DUK_ASSERT(duk_is_pointer(ctx, 0));
-+	duk_set_top(ctx, 1);
-+
-+	if (duk_is_constructor_call(ctx)) {
-+		duk_push_object_helper(ctx,
-+		                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_POINTER),
-+		                       DUK_BIDX_POINTER_PROTOTYPE);
-+
-+		/* Pointer object internal value is immutable */
-+		duk_dup(ctx, 0);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
-+	}
-+	/* Note: unbalanced stack on purpose */
-+
-+	return 1;
-+}
-+
-+/*
-+ *  toString(), valueOf()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_pointer_prototype_tostring_shared(duk_context *ctx) {
-+	duk_tval *tv;
-+	duk_small_int_t to_string = duk_get_current_magic(ctx);
-+
-+	duk_push_this(ctx);
-+	tv = duk_require_tval(ctx, -1);
-+	DUK_ASSERT(tv != NULL);
-+
-+	if (DUK_TVAL_IS_POINTER(tv)) {
-+		/* nop */
-+	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-+		duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+
-+		/* Must be a "pointer object", i.e. class "Pointer" */
-+		if (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_POINTER) {
-+			goto type_error;
-+		}
-+
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-+	} else {
-+		goto type_error;
-+	}
-+
-+	if (to_string) {
-+		duk_to_string(ctx, -1);
-+	}
-+	return 1;
-+
-+ type_error:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+#line 1 "duk_bi_proxy.c"
-+/*
-+ *  Proxy built-in (ES6 draft)
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) {
-+	duk_hobject *h_target;
-+	duk_hobject *h_handler;
-+
-+	if (!duk_is_constructor_call(ctx)) {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+
-+	/* Reject a proxy object as the target because it would need
-+	 * special handler in property lookups.  (ES6 has no such restriction)
-+	 */
-+	h_target = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-+	DUK_ASSERT(h_target != NULL);
-+	if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_target)) {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+
-+	/* Reject a proxy object as the handler because it would cause
-+	 * potentially unbounded recursion.  (ES6 has no such restriction)
-+	 */
-+	h_handler = duk_require_hobject_or_lfunc_coerce(ctx, 1);
-+	DUK_ASSERT(h_handler != NULL);
-+	if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h_handler)) {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+
-+	/* XXX: the returned value is exotic in ES6 (draft), but we use a
-+	 * simple object here with no prototype.  Without a prototype,
-+	 * [[DefaultValue]] coercion fails which is abit confusing.
-+	 * No callable check/handling in the current Proxy subset.
-+	 */
-+	(void) duk_push_object_helper_proto(ctx,
-+	                                    DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                                    DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ |
-+	                                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-+	                                    NULL);
-+	DUK_ASSERT_TOP(ctx, 3);
-+
-+	/* Proxy target */
-+	duk_dup(ctx, 0);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_WC);
-+
-+	/* Proxy handler */
-+	duk_dup(ctx, 1);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_HANDLER, DUK_PROPDESC_FLAGS_WC);
-+
-+	return 1;  /* replacement handler */
-+}
-+#else  /* DUK_USE_ES6_PROXY */
-+DUK_INTERNAL duk_ret_t duk_bi_proxy_constructor(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+#endif  /* DUK_USE_ES6_PROXY */
-+#line 1 "duk_bi_regexp.c"
-+/*
-+ *  RegExp built-ins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+
-+DUK_LOCAL void duk__get_this_regexp(duk_context *ctx) {
-+	duk_hobject *h;
-+
-+	duk_push_this(ctx);
-+	h = duk_require_hobject_with_class(ctx, -1, DUK_HOBJECT_CLASS_REGEXP);
-+	DUK_ASSERT(h != NULL);
-+	DUK_UNREF(h);
-+	duk_insert(ctx, 0);  /* prepend regexp to valstack 0 index */
-+}
-+
-+/* XXX: much to improve (code size) */
-+DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *h_pattern;
-+
-+	DUK_ASSERT_TOP(ctx, 2);
-+	h_pattern = duk_get_hobject(ctx, 0);
-+
-+	if (!duk_is_constructor_call(ctx) &&
-+	    h_pattern != NULL &&
-+	    DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP &&
-+	    duk_is_undefined(ctx, 1)) {
-+		/* Called as a function, pattern has [[Class]] "RegExp" and
-+		 * flags is undefined -> return object as is.
-+		 */
-+		duk_dup(ctx, 0);
-+		return 1;
-+	}
-+
-+	/* Else functionality is identical for function call and constructor
-+	 * call.
-+	 */
-+
-+	if (h_pattern != NULL &&
-+	    DUK_HOBJECT_GET_CLASS_NUMBER(h_pattern) == DUK_HOBJECT_CLASS_REGEXP) {
-+		if (duk_is_undefined(ctx, 1)) {
-+			duk_bool_t flag_g, flag_i, flag_m;
-+			duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE);
-+			flag_g = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
-+			flag_i = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_IGNORE_CASE, NULL);
-+			flag_m = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_MULTILINE, NULL);
-+
-+			duk_push_sprintf(ctx, "%s%s%s",
-+			                 (const char *) (flag_g ? "g" : ""),
-+			                 (const char *) (flag_i ? "i" : ""),
-+			                 (const char *) (flag_m ? "m" : ""));
-+
-+			/* [ ... pattern flags ] */
-+		} else {
-+			return DUK_RET_TYPE_ERROR;
-+		}
-+	} else {
-+		if (duk_is_undefined(ctx, 0)) {
-+			duk_push_string(ctx, "");
-+		} else {
-+			duk_dup(ctx, 0);
-+			duk_to_string(ctx, -1);
-+		}
-+		if (duk_is_undefined(ctx, 1)) {
-+			duk_push_string(ctx, "");
-+		} else {
-+			duk_dup(ctx, 1);
-+			duk_to_string(ctx, -1);
-+		}
-+
-+		/* [ ... pattern flags ] */
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("RegExp constructor/function call, pattern=%!T, flags=%!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -2), (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/* [ ... pattern flags ] */
-+
-+	duk_regexp_compile(thr);
-+
-+	/* [ ... bytecode escaped_source ] */
-+
-+	duk_regexp_create_instance(thr);
-+
-+	/* [ ... RegExp ] */
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_exec(duk_context *ctx) {
-+	duk__get_this_regexp(ctx);
-+
-+	/* [ regexp input ] */
-+
-+	duk_regexp_match((duk_hthread *) ctx);
-+
-+	/* [ result ] */
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_test(duk_context *ctx) {
-+	duk__get_this_regexp(ctx);
-+
-+	/* [ regexp input ] */
-+
-+	/* result object is created and discarded; wasteful but saves code space */
-+	duk_regexp_match((duk_hthread *) ctx);
-+
-+	/* [ result ] */
-+
-+	duk_push_boolean(ctx, (duk_is_null(ctx, -1) ? 0 : 1));
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx) {
-+	duk_hstring *h_bc;
-+	duk_small_int_t re_flags;
-+
-+#if 0
-+	/* A little tricky string approach to provide the flags string.
-+	 * This depends on the specific flag values in duk_regexp.h,
-+	 * which needs to be asserted for.  In practice this doesn't
-+	 * produce more compact code than the easier approach in use.
-+	 */
-+
-+	const char *flag_strings = "gim\0gi\0gm\0g\0";
-+	duk_uint8_t flag_offsets[8] = {
-+		(duk_uint8_t) 3,   /* flags: ""    */
-+		(duk_uint8_t) 10,  /* flags: "g"   */
-+		(duk_uint8_t) 5,   /* flags: "i"   */
-+		(duk_uint8_t) 4,   /* flags: "gi"  */
-+		(duk_uint8_t) 2,   /* flags: "m"   */
-+		(duk_uint8_t) 7,   /* flags: "gm"  */
-+		(duk_uint8_t) 1,   /* flags: "im"  */
-+		(duk_uint8_t) 0,   /* flags: "gim" */
-+	};
-+	DUK_ASSERT(DUK_RE_FLAG_GLOBAL == 1);
-+	DUK_ASSERT(DUK_RE_FLAG_IGNORE_CASE == 2);
-+	DUK_ASSERT(DUK_RE_FLAG_MULTILINE == 4);
-+#endif
-+
-+	duk__get_this_regexp(ctx);
-+
-+	/* [ regexp ] */
-+
-+	duk_get_prop_stridx(ctx, 0, DUK_STRIDX_SOURCE);
-+	duk_get_prop_stridx(ctx, 0, DUK_STRIDX_INT_BYTECODE);
-+	h_bc = duk_get_hstring(ctx, -1);
-+	DUK_ASSERT(h_bc != NULL);
-+	DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1);
-+	DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1);
-+	DUK_ASSERT(DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80);
-+	re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
-+
-+	/* [ regexp source bytecode ] */
-+
-+#if 1
-+	/* This is a cleaner approach and also produces smaller code than
-+	 * the other alternative.  Use duk_require_string() for format
-+	 * safety (although the source property should always exist).
-+	 */
-+	duk_push_sprintf(ctx, "/%s/%s%s%s",
-+	                 (const char *) duk_require_string(ctx, -2),  /* require to be safe */
-+	                 (re_flags & DUK_RE_FLAG_GLOBAL) ? "g" : "",
-+	                 (re_flags & DUK_RE_FLAG_IGNORE_CASE) ? "i" : "",
-+	                 (re_flags & DUK_RE_FLAG_MULTILINE) ? "m" : "");
-+#else
-+	/* This should not be necessary because no-one should tamper with the
-+	 * regexp bytecode, but is prudent to avoid potential segfaults if that
-+	 * were to happen for some reason.
-+	 */
-+	re_flags &= 0x07;
-+	DUK_ASSERT(re_flags >= 0 && re_flags <= 7);  /* three flags */
-+	duk_push_sprintf(ctx, "/%s/%s",
-+	                 (const char *) duk_require_string(ctx, -2),
-+	                 (const char *) (flag_strings + flag_offsets[re_flags]));
-+#endif
-+
-+	return 1;
-+}
-+
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_regexp_constructor(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_exec(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_test(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_regexp_prototype_to_string(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+#line 1 "duk_bi_string.c"
-+/*
-+ *  String built-ins
-+ */
-+
-+/* XXX: There are several limitations in the current implementation for
-+ * strings with >= 0x80000000UL characters.  In some cases one would need
-+ * to be able to represent the range [-0xffffffff,0xffffffff] and so on.
-+ * Generally character and byte length are assumed to fit into signed 32
-+ * bits (< 0x80000000UL).  Places with issues are not marked explicitly
-+ * below in all cases, look for signed type usage (duk_int_t etc) for
-+ * offsets/lengths.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Constructor
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_constructor(duk_context *ctx) {
-+	/* String constructor needs to distinguish between an argument not given at all
-+	 * vs. given as 'undefined'.  We're a vararg function to handle this properly.
-+	 */
-+
-+	if (duk_get_top(ctx) == 0) {
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
-+	} else {
-+		duk_to_string(ctx, 0);
-+	}
-+	DUK_ASSERT(duk_is_string(ctx, 0));
-+	duk_set_top(ctx, 1);
-+
-+	if (duk_is_constructor_call(ctx)) {
-+		duk_push_object_helper(ctx,
-+		                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		                       DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ |
-+		                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_STRING),
-+		                       DUK_BIDX_STRING_PROTOTYPE);
-+
-+		/* String object internal value is immutable */
-+		duk_dup(ctx, 0);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VALUE, DUK_PROPDESC_FLAGS_NONE);
-+	}
-+	/* Note: unbalanced stack on purpose */
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_constructor_from_char_code(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hbuffer_dynamic *h;
-+	duk_idx_t i, n;
-+	duk_ucodepoint_t cp;
-+
-+	/* XXX: It would be nice to build the string directly but ToUint16()
-+	 * coercion is needed so a generic helper would not be very
-+	 * helpful (perhaps coerce the value stack first here and then
-+	 * build a string from a duk_tval number sequence in one go?).
-+	 */
-+
-+	n = duk_get_top(ctx);
-+	duk_push_dynamic_buffer(ctx, 0);  /* XXX: initial spare size estimate from 'n' */
-+	h = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+
-+	for (i = 0; i < n; i++) {
-+#if defined(DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT)
-+		/* ToUint16() coercion is mandatory in the E5.1 specification, but
-+		 * this non-compliant behavior makes more sense because we support
-+		 * non-BMP codepoints.  Don't use CESU-8 because that'd create
-+		 * surrogate pairs.
-+		 */
-+		cp = (duk_ucodepoint_t) duk_to_uint32(ctx, i);
-+		duk_hbuffer_append_xutf8(thr, h, cp);
-+#else
-+		cp = (duk_ucodepoint_t) duk_to_uint16(ctx, i);
-+		duk_hbuffer_append_cesu8(thr, h, cp);
-+#endif
-+	}
-+
-+	duk_to_string(ctx, -1);
-+	return 1;
-+}
-+
-+/*
-+ *  toString(), valueOf()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_to_string(duk_context *ctx) {
-+	duk_tval *tv;
-+
-+	duk_push_this(ctx);
-+	tv = duk_require_tval(ctx, -1);
-+	DUK_ASSERT(tv != NULL);
-+
-+	if (DUK_TVAL_IS_STRING(tv)) {
-+		/* return as is */
-+		return 1;
-+	} else if (DUK_TVAL_IS_OBJECT(tv)) {
-+		duk_hobject *h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+
-+		/* Must be a "string object", i.e. class "String" */
-+		if (DUK_HOBJECT_GET_CLASS_NUMBER(h) != DUK_HOBJECT_CLASS_STRING) {
-+			goto type_error;
-+		}
-+
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VALUE);
-+		DUK_ASSERT(duk_is_string(ctx, -1));
-+
-+		return 1;
-+	} else {
-+		goto type_error;
-+	}
-+
-+	/* never here, but fall through */
-+
-+ type_error:
-+	return DUK_RET_TYPE_ERROR;
-+}
-+
-+/*
-+ *  Character and charcode access
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_at(duk_context *ctx) {
-+	duk_int_t pos;
-+
-+	/* XXX: faster implementation */
-+
-+	(void) duk_push_this_coercible_to_string(ctx);
-+	pos = duk_to_int(ctx, 0);
-+	duk_substring(ctx, -1, pos, pos + 1);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_char_code_at(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_int_t pos;
-+	duk_hstring *h;
-+	duk_bool_t clamped;
-+
-+	/* XXX: faster implementation */
-+
-+	DUK_DDD(DUK_DDDPRINT("arg=%!T", (duk_tval *) duk_get_tval(ctx, 0)));
-+
-+	h = duk_push_this_coercible_to_string(ctx);
-+	DUK_ASSERT(h != NULL);
-+
-+	pos = duk_to_int_clamped_raw(ctx,
-+	                             0 /*index*/,
-+	                             0 /*min(incl)*/,
-+	                             DUK_HSTRING_GET_CHARLEN(h) - 1 /*max(incl)*/,
-+	                             &clamped /*out_clamped*/);
-+	if (clamped) {
-+		duk_push_number(ctx, DUK_DOUBLE_NAN);
-+		return 1;
-+	}
-+
-+	duk_push_u32(ctx, (duk_uint32_t) duk_hstring_char_code_at_raw(thr, h, pos));
-+	return 1;
-+}
-+
-+/*
-+ *  substring(), substr(), slice()
-+ */
-+
-+/* XXX: any chance of merging these three similar but still slightly
-+ * different algorithms so that footprint would be reduced?
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substring(duk_context *ctx) {
-+	duk_hstring *h;
-+	duk_int_t start_pos, end_pos;
-+	duk_int_t len;
-+
-+	h = duk_push_this_coercible_to_string(ctx);
-+	DUK_ASSERT(h != NULL);
-+	len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
-+
-+	/* [ start end str ] */
-+
-+	start_pos = duk_to_int_clamped(ctx, 0, 0, len);
-+	if (duk_is_undefined(ctx, 1)) {
-+		end_pos = len;
-+	} else {
-+		end_pos = duk_to_int_clamped(ctx, 1, 0, len);
-+	}
-+	DUK_ASSERT(start_pos >= 0 && start_pos <= len);
-+	DUK_ASSERT(end_pos >= 0 && end_pos <= len);
-+
-+	if (start_pos > end_pos) {
-+		duk_int_t tmp = start_pos;
-+		start_pos = end_pos;
-+		end_pos = tmp;
-+	}
-+
-+	DUK_ASSERT(end_pos >= start_pos);
-+
-+	duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
-+	return 1;
-+}
-+
-+#ifdef DUK_USE_SECTION_B
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx) {
-+	duk_hstring *h;
-+	duk_int_t start_pos, end_pos;
-+	duk_int_t len;
-+
-+	/* Unlike non-obsolete String calls, substr() algorithm in E5.1
-+	 * specification will happily coerce undefined and null to strings
-+	 * ("undefined" and "null").
-+	 */
-+	duk_push_this(ctx);
-+	h = duk_to_hstring(ctx, -1);
-+	DUK_ASSERT(h != NULL);
-+	len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
-+
-+	/* [ start length str ] */
-+
-+	/* The implementation for computing of start_pos and end_pos differs
-+	 * from the standard algorithm, but is intended to result in the exactly
-+	 * same behavior.  This is not always obvious.
-+	 */
-+
-+	/* combines steps 2 and 5; -len ensures max() not needed for step 5 */
-+	start_pos = duk_to_int_clamped(ctx, 0, -len, len);
-+	if (start_pos < 0) {
-+		start_pos = len + start_pos;
-+	}
-+	DUK_ASSERT(start_pos >= 0 && start_pos <= len);
-+
-+	/* combines steps 3, 6; step 7 is not needed */
-+	if (duk_is_undefined(ctx, 1)) {
-+		end_pos = len;
-+	} else {
-+		DUK_ASSERT(start_pos <= len);
-+		end_pos = start_pos + duk_to_int_clamped(ctx, 1, 0, len - start_pos);
-+	}
-+	DUK_ASSERT(start_pos >= 0 && start_pos <= len);
-+	DUK_ASSERT(end_pos >= 0 && end_pos <= len);
-+	DUK_ASSERT(end_pos >= start_pos);
-+
-+	duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
-+	return 1;
-+}
-+#else  /* DUK_USE_SECTION_B */
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_substr(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+#endif  /* DUK_USE_SECTION_B */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_slice(duk_context *ctx) {
-+	duk_hstring *h;
-+	duk_int_t start_pos, end_pos;
-+	duk_int_t len;
-+
-+	h = duk_push_this_coercible_to_string(ctx);
-+	DUK_ASSERT(h != NULL);
-+	len = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h);
-+
-+	/* [ start end str ] */
-+
-+	start_pos = duk_to_int_clamped(ctx, 0, -len, len);
-+	if (start_pos < 0) {
-+		start_pos = len + start_pos;
-+	}
-+	if (duk_is_undefined(ctx, 1)) {
-+		end_pos = len;
-+	} else {
-+		end_pos = duk_to_int_clamped(ctx, 1, -len, len);
-+		if (end_pos < 0) {
-+			end_pos = len + end_pos;
-+		}
-+	}
-+	DUK_ASSERT(start_pos >= 0 && start_pos <= len);
-+	DUK_ASSERT(end_pos >= 0 && end_pos <= len);
-+
-+	if (end_pos < start_pos) {
-+		end_pos = start_pos;
-+	}
-+
-+	DUK_ASSERT(end_pos >= start_pos);
-+
-+	duk_substring(ctx, -1, (duk_size_t) start_pos, (duk_size_t) end_pos);
-+	return 1;
-+}
-+
-+/*
-+ *  Case conversion
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_caseconv_shared(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_small_int_t uppercase = duk_get_current_magic(ctx);
-+
-+	(void) duk_push_this_coercible_to_string(ctx);
-+	duk_unicode_case_convert_string(thr, (duk_bool_t) uppercase);
-+	return 1;
-+}
-+
-+/*
-+ *  indexOf() and lastIndexOf()
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_indexof_shared(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_this;
-+	duk_hstring *h_search;
-+	duk_int_t clen_this;
-+	duk_int_t cpos;
-+	duk_int_t bpos;
-+	const duk_uint8_t *p_start, *p_end, *p;
-+	const duk_uint8_t *q_start;
-+	duk_int_t q_blen;
-+	duk_uint8_t firstbyte;
-+	duk_uint8_t t;
-+	duk_small_int_t is_lastindexof = duk_get_current_magic(ctx);  /* 0=indexOf, 1=lastIndexOf */
-+
-+	h_this = duk_push_this_coercible_to_string(ctx);
-+	DUK_ASSERT(h_this != NULL);
-+	clen_this = (duk_int_t) DUK_HSTRING_GET_CHARLEN(h_this);
-+
-+	h_search = duk_to_hstring(ctx, 0);
-+	DUK_ASSERT(h_search != NULL);
-+	q_start = DUK_HSTRING_GET_DATA(h_search);
-+	q_blen = (duk_int_t) DUK_HSTRING_GET_BYTELEN(h_search);
-+
-+	duk_to_number(ctx, 1);
-+	if (duk_is_nan(ctx, 1) && is_lastindexof) {
-+		/* indexOf: NaN should cause pos to be zero.
-+		 * lastIndexOf: NaN should cause pos to be +Infinity
-+		 * (and later be clamped to len).
-+		 */
-+		cpos = clen_this;
-+	} else {
-+		cpos = duk_to_int_clamped(ctx, 1, 0, clen_this);
-+	}
-+
-+	/* Empty searchstring always matches; cpos must be clamped here.
-+	 * (If q_blen were < 0 due to clamped coercion, it would also be
-+	 * caught here.)
-+	 */
-+	if (q_blen <= 0) {
-+		duk_push_int(ctx, cpos);
-+		return 1;
-+	}
-+	DUK_ASSERT(q_blen > 0);
-+
-+	bpos = (duk_int_t) duk_heap_strcache_offset_char2byte(thr, h_this, (duk_uint32_t) cpos);
-+
-+	p_start = DUK_HSTRING_GET_DATA(h_this);
-+	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_this);
-+	p = p_start + bpos;
-+
-+	/* This loop is optimized for size.  For speed, there should be
-+	 * two separate loops, and we should ensure that memcmp() can be
-+	 * used without an extra "will searchstring fit" check.  Doing
-+	 * the preconditioning for 'p' and 'p_end' is easy but cpos
-+	 * must be updated if 'p' is wound back (backward scanning).
-+	 */
-+
-+	firstbyte = q_start[0];  /* leading byte of match string */
-+	while (p <= p_end && p >= p_start) {
-+		t = *p;
-+
-+		/* For Ecmascript strings, this check can only match for
-+		 * initial UTF-8 bytes (not continuation bytes).  For other
-+		 * strings all bets are off.
-+		 */
-+
-+		if ((t == firstbyte) && ((duk_size_t) (p_end - p) >= (duk_size_t) q_blen)) {
-+			DUK_ASSERT(q_blen > 0);  /* no issues with memcmp() zero size, even if broken */
-+			if (DUK_MEMCMP(p, q_start, (duk_size_t) q_blen) == 0) {
-+				duk_push_int(ctx, cpos);
-+				return 1;
-+			}
-+		}
-+
-+		/* track cpos while scanning */
-+		if (is_lastindexof) {
-+			/* when going backwards, we decrement cpos 'early';
-+			 * 'p' may point to a continuation byte of the char
-+			 * at offset 'cpos', but that's OK because we'll
-+			 * backtrack all the way to the initial byte.
-+			 */
-+			if ((t & 0xc0) != 0x80) {
-+				cpos--;
-+			}
-+			p--;
-+		} else {
-+			if ((t & 0xc0) != 0x80) {
-+				cpos++;
-+			}
-+			p++;
-+		}
-+	}
-+
-+	/* Not found.  Empty string case is handled specially above. */
-+	duk_push_int(ctx, -1);
-+	return 1;
-+}
-+
-+/*
-+ *  replace()
-+ */
-+
-+/* XXX: the current implementation works but is quite clunky; it compiles
-+ * to almost 1,4kB of x86 code so it needs to be simplified (better approach,
-+ * shared helpers, etc).  Some ideas for refactoring:
-+ *
-+ * - a primitive to convert a string into a regexp matcher (reduces matching
-+ *   code at the cost of making matching much slower)
-+ * - use replace() as a basic helper for match() and split(), which are both
-+ *   much simpler
-+ * - API call to get_prop and to_boolean
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_replace(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_input;
-+	duk_hstring *h_match;
-+	duk_hstring *h_search;
-+	duk_hobject *h_re;
-+	duk_hbuffer_dynamic *h_buf;
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+	duk_bool_t is_regexp;
-+	duk_bool_t is_global;
-+#endif
-+	duk_bool_t is_repl_func;
-+	duk_uint32_t match_start_coff, match_start_boff;
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+	duk_int_t match_caps;
-+#endif
-+	duk_uint32_t prev_match_end_boff;
-+	const duk_uint8_t *r_start, *r_end, *r;   /* repl string scan */
-+
-+	DUK_ASSERT_TOP(ctx, 2);
-+	h_input = duk_push_this_coercible_to_string(ctx);
-+	DUK_ASSERT(h_input != NULL);
-+	duk_push_dynamic_buffer(ctx, 0);
-+	h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(h_buf != NULL);
-+	DUK_ASSERT_TOP(ctx, 4);
-+
-+	/* stack[0] = search value
-+	 * stack[1] = replace value
-+	 * stack[2] = input string
-+	 * stack[3] = result buffer
-+	 */
-+
-+	h_re = duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP);
-+	if (h_re) {
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		is_regexp = 1;
-+		is_global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
-+
-+		if (is_global) {
-+			/* start match from beginning */
-+			duk_push_int(ctx, 0);
-+			duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-+		}
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+		return DUK_RET_UNSUPPORTED_ERROR;
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+	} else {
-+		duk_to_string(ctx, 0);
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		is_regexp = 0;
-+		is_global = 0;
-+#endif
-+	}
-+
-+	if (duk_is_function(ctx, 1)) {
-+		is_repl_func = 1;
-+		r_start = NULL;
-+		r_end = NULL;
-+	} else {
-+		duk_hstring *h_repl;
-+
-+		is_repl_func = 0;
-+		h_repl = duk_to_hstring(ctx, 1);
-+		DUK_ASSERT(h_repl != NULL);
-+		r_start = DUK_HSTRING_GET_DATA(h_repl);
-+		r_end = r_start + DUK_HSTRING_GET_BYTELEN(h_repl);
-+	}
-+
-+	prev_match_end_boff = 0;
-+
-+	for (;;) {
-+		/*
-+		 *  If matching with a regexp:
-+		 *    - non-global RegExp: lastIndex not touched on a match, zeroed
-+		 *      on a non-match
-+		 *    - global RegExp: on match, lastIndex will be updated by regexp
-+		 *      executor to point to next char after the matching part (so that
-+		 *      characters in the matching part are not matched again)
-+		 *
-+		 *  If matching with a string:
-+		 *    - always non-global match, find first occurrence
-+		 *
-+		 *  We need:
-+		 *    - The character offset of start-of-match for the replacer function
-+		 *    - The byte offsets for start-of-match and end-of-match to implement
-+		 *      the replacement values $&, $`, and $', and to copy non-matching
-+		 *      input string portions (including header and trailer) verbatim.
-+		 *
-+		 *  NOTE: the E5.1 specification is a bit vague how the RegExp should
-+		 *  behave in the replacement process; e.g. is matching done first for
-+		 *  all matches (in the global RegExp case) before any replacer calls
-+		 *  are made?  See: test-bi-string-proto-replace.js for discussion.
-+		 */
-+
-+		DUK_ASSERT_TOP(ctx, 4);
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		if (is_regexp) {
-+			duk_dup(ctx, 0);
-+			duk_dup(ctx, 2);
-+			duk_regexp_match(thr);  /* [ ... regexp input ] -> [ res_obj ] */
-+			if (!duk_is_object(ctx, -1)) {
-+				duk_pop(ctx);
-+				break;
-+			}
-+
-+			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
-+			DUK_ASSERT(duk_is_number(ctx, -1));
-+			match_start_coff = duk_get_int(ctx, -1);
-+			duk_pop(ctx);
-+
-+			duk_get_prop_index(ctx, -1, 0);
-+			DUK_ASSERT(duk_is_string(ctx, -1));
-+			h_match = duk_get_hstring(ctx, -1);
-+			DUK_ASSERT(h_match != NULL);
-+			duk_pop(ctx);  /* h_match is borrowed, remains reachable through match_obj */
-+
-+			if (DUK_HSTRING_GET_BYTELEN(h_match) == 0) {
-+				/* This should be equivalent to match() algorithm step 8.f.iii.2:
-+				 * detect an empty match and allow it, but don't allow it twice.
-+				 */
-+				duk_uint32_t last_index;
-+
-+				duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-+				last_index = (duk_uint32_t) duk_get_uint(ctx, -1);
-+				DUK_DDD(DUK_DDDPRINT("empty match, bump lastIndex: %ld -> %ld",
-+				                     (long) last_index, (long) (last_index + 1)));
-+				duk_pop(ctx);
-+				duk_push_int(ctx, last_index + 1);
-+				duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-+			}
-+
-+			DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_INT_MAX);  /* string limits */
-+			match_caps = (duk_int_t) duk_get_length(ctx, -1);
-+		} else {
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+		{  /* unconditionally */
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+			const duk_uint8_t *p_start, *p_end, *p;   /* input string scan */
-+			const duk_uint8_t *q_start;               /* match string */
-+			duk_size_t q_blen;
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+			DUK_ASSERT(!is_global);  /* single match always */
-+#endif
-+
-+			p_start = DUK_HSTRING_GET_DATA(h_input);
-+			p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
-+			p = p_start;
-+
-+			h_search = duk_get_hstring(ctx, 0);
-+			DUK_ASSERT(h_search != NULL);
-+			q_start = DUK_HSTRING_GET_DATA(h_search);
-+			q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_search);
-+
-+			p_end -= q_blen;  /* ensure full memcmp() fits in while */
-+
-+			match_start_coff = 0;
-+
-+			while (p <= p_end) {
-+				DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
-+				if (DUK_MEMCMP((void *) p, (void *) q_start, (size_t) q_blen) == 0) {
-+					duk_dup(ctx, 0);
-+					h_match = duk_get_hstring(ctx, -1);
-+					DUK_ASSERT(h_match != NULL);
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+					match_caps = 0;
-+#endif
-+					goto found;
-+				}
-+
-+				/* track utf-8 non-continuation bytes */
-+				if ((p[0] & 0xc0) != 0x80) {
-+					match_start_coff++;
-+				}
-+				p++;
-+			}
-+
-+			/* not found */
-+			break;
-+		}
-+	 found:
-+
-+		/* stack[0] = search value
-+		 * stack[1] = replace value
-+		 * stack[2] = input string
-+		 * stack[3] = result buffer
-+		 * stack[4] = regexp match OR match string
-+		 */
-+
-+		match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
-+
-+		duk_hbuffer_append_bytes(thr,
-+		                         h_buf,
-+		                         DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff,
-+		                         (duk_size_t) (match_start_boff - prev_match_end_boff));
-+
-+		prev_match_end_boff = match_start_boff + DUK_HSTRING_GET_BYTELEN(h_match);
-+
-+		if (is_repl_func) {
-+			duk_idx_t idx_args;
-+			duk_hstring *h_repl;
-+
-+			/* regexp res_obj is at index 4 */
-+
-+			duk_dup(ctx, 1);
-+			idx_args = duk_get_top(ctx);
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+			if (is_regexp) {
-+				duk_int_t idx;
-+				duk_require_stack(ctx, match_caps + 2);
-+				for (idx = 0; idx < match_caps; idx++) {
-+					/* match followed by capture(s) */
-+					duk_get_prop_index(ctx, 4, idx);
-+				}
-+			} else {
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+			{  /* unconditionally */
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+				/* match == search string, by definition */
-+				duk_dup(ctx, 0);
-+			}
-+			duk_push_int(ctx, match_start_coff);
-+			duk_dup(ctx, 2);
-+
-+			/* [ ... replacer match [captures] match_char_offset input ] */
-+
-+			duk_call(ctx, duk_get_top(ctx) - idx_args);
-+			h_repl = duk_to_hstring(ctx, -1);  /* -> [ ... repl_value ] */
-+			DUK_ASSERT(h_repl != NULL);
-+			duk_hbuffer_append_hstring(thr, h_buf, h_repl);
-+			duk_pop(ctx);  /* repl_value */
-+		} else {
-+			r = r_start;
-+
-+			while (r < r_end) {
-+				duk_int_t ch1;
-+				duk_int_t ch2;
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+				duk_int_t ch3;
-+#endif
-+				duk_size_t left;
-+
-+				ch1 = *r++;
-+				if (ch1 != DUK_ASC_DOLLAR) {
-+					goto repl_write;
-+				}
-+				left = r_end - r;
-+
-+				if (left <= 0) {
-+					goto repl_write;
-+				}
-+
-+				ch2 = r[0];
-+				switch ((int) ch2) {
-+				case DUK_ASC_DOLLAR: {
-+					ch1 = (1 << 8) + DUK_ASC_DOLLAR;
-+					goto repl_write;
-+				}
-+				case DUK_ASC_AMP: {
-+					duk_hbuffer_append_hstring(thr, h_buf, h_match);
-+					r++;
-+					continue;
-+				}
-+				case DUK_ASC_GRAVE: {
-+					duk_hbuffer_append_bytes(thr,
-+					                         h_buf,
-+					                         DUK_HSTRING_GET_DATA(h_input),
-+					                         match_start_boff);
-+					r++;
-+					continue;
-+				}
-+				case DUK_ASC_SINGLEQUOTE: {
-+					duk_uint32_t match_end_boff;
-+
-+					/* Use match charlen instead of bytelen, just in case the input and
-+					 * match codepoint encodings would have different lengths.
-+					 */
-+					match_end_boff = duk_heap_strcache_offset_char2byte(thr,
-+					                                                    h_input,
-+					                                                    match_start_coff + DUK_HSTRING_GET_CHARLEN(h_match));
-+
-+					duk_hbuffer_append_bytes(thr,
-+					                         h_buf,
-+					                         DUK_HSTRING_GET_DATA(h_input) + match_end_boff,
-+					                         DUK_HSTRING_GET_BYTELEN(h_input) - match_end_boff);
-+					r++;
-+					continue;
-+				}
-+				default: {
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+					duk_int_t capnum, captmp, capadv;
-+					/* XXX: optional check, match_caps is zero if no regexp,
-+					 * so dollar will be interpreted literally anyway.
-+					 */
-+
-+					if (!is_regexp) {
-+						goto repl_write;
-+					}
-+
-+					if (!(ch2 >= DUK_ASC_0 && ch2 <= DUK_ASC_9)) {
-+						goto repl_write;
-+					}
-+					capnum = ch2 - DUK_ASC_0;
-+					capadv = 1;
-+
-+					if (left >= 2) {
-+						ch3 = r[1];
-+						if (ch3 >= DUK_ASC_0 && ch3 <= DUK_ASC_9) {
-+							captmp = capnum * 10 + (ch3 - DUK_ASC_0);
-+							if (captmp < match_caps) {
-+								capnum = captmp;
-+								capadv = 2;
-+							}
-+						}
-+					}
-+
-+					if (capnum > 0 && capnum < match_caps) {
-+						DUK_ASSERT(is_regexp != 0);  /* match_caps == 0 without regexps */
-+
-+						/* regexp res_obj is at offset 4 */
-+						duk_get_prop_index(ctx, 4, (duk_uarridx_t) capnum);
-+						if (duk_is_string(ctx, -1)) {
-+							DUK_ASSERT(duk_get_hstring(ctx, -1) != NULL);
-+							duk_hbuffer_append_hstring(thr, h_buf, duk_get_hstring(ctx, -1));
-+						} else {
-+							/* undefined -> skip (replaced with empty) */
-+						}
-+						duk_pop(ctx);
-+						r += capadv;
-+						continue;
-+					} else {
-+						goto repl_write;
-+					}
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+					goto repl_write;  /* unconditionally */
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+				}  /* default case */
-+				}  /* switch (ch2) */
-+
-+			 repl_write:
-+				/* ch1 = (r_increment << 8) + byte */
-+				duk_hbuffer_append_byte(thr, h_buf, (duk_uint8_t) (ch1 & 0xff));
-+				r += ch1 >> 8;
-+			}  /* while repl */
-+		}  /* if (is_repl_func) */
-+
-+		duk_pop(ctx);  /* pop regexp res_obj or match string */
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		if (!is_global) {
-+#else
-+		{  /* unconditionally; is_global==0 */
-+#endif
-+			break;
-+		}
-+	}
-+
-+	/* trailer */
-+	duk_hbuffer_append_bytes(thr,
-+	                         h_buf,
-+	                         DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff,
-+	                         (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff));
-+
-+	DUK_ASSERT_TOP(ctx, 4);
-+	duk_to_string(ctx, -1);
-+	return 1;
-+}
-+
-+/*
-+ *  split()
-+ */
-+
-+/* XXX: very messy now, but works; clean up, remove unused variables (nomimally
-+ * used so compiler doesn't complain).
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_split(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_input;
-+	duk_hstring *h_sep;
-+	duk_uint32_t limit;
-+	duk_uint32_t arr_idx;
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+	duk_bool_t is_regexp;
-+#endif
-+	duk_bool_t matched;  /* set to 1 if any match exists (needed for empty input special case) */
-+	duk_uint32_t prev_match_end_coff, prev_match_end_boff;
-+	duk_uint32_t match_start_boff, match_start_coff;
-+	duk_uint32_t match_end_boff, match_end_coff;
-+
-+	DUK_UNREF(thr);
-+
-+	h_input = duk_push_this_coercible_to_string(ctx);
-+	DUK_ASSERT(h_input != NULL);
-+
-+	duk_push_array(ctx);
-+
-+	if (duk_is_undefined(ctx, 1)) {
-+		limit = 0xffffffffUL;
-+	} else {
-+		limit = duk_to_uint32(ctx, 1);
-+	}
-+
-+	if (limit == 0) {
-+		return 1;
-+	}
-+
-+	/* If the separator is a RegExp, make a "clone" of it.  The specification
-+	 * algorithm calls [[Match]] directly for specific indices; we emulate this
-+	 * by tweaking lastIndex and using a "force global" variant of duk_regexp_match()
-+	 * which will use global-style matching even when the RegExp itself is non-global.
-+	 */
-+
-+	if (duk_is_undefined(ctx, 0)) {
-+		/* The spec algorithm first does "R = ToString(separator)" before checking
-+		 * whether separator is undefined.  Since this is side effect free, we can
-+		 * skip the ToString() here.
-+		 */
-+		duk_dup(ctx, 2);
-+		duk_put_prop_index(ctx, 3, 0);
-+		return 1;
-+	} else if (duk_get_hobject_with_class(ctx, 0, DUK_HOBJECT_CLASS_REGEXP) != NULL) {
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR);
-+		duk_dup(ctx, 0);
-+		duk_new(ctx, 1);  /* [ ... RegExp val ] -> [ ... res ] */
-+		duk_replace(ctx, 0);
-+		/* lastIndex is initialized to zero by new RegExp() */
-+		is_regexp = 1;
-+#else
-+		return DUK_RET_UNSUPPORTED_ERROR;
-+#endif
-+	} else {
-+		duk_to_string(ctx, 0);
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		is_regexp = 0;
-+#endif
-+	}
-+
-+	/* stack[0] = separator (string or regexp)
-+	 * stack[1] = limit
-+	 * stack[2] = input string
-+	 * stack[3] = result array
-+	 */
-+
-+	prev_match_end_boff = 0;
-+	prev_match_end_coff = 0;
-+	arr_idx = 0;
-+	matched = 0;
-+
-+	for (;;) {
-+		/*
-+		 *  The specification uses RegExp [[Match]] to attempt match at specific
-+		 *  offsets.  We don't have such a primitive, so we use an actual RegExp
-+		 *  and tweak lastIndex.  Since the RegExp may be non-global, we use a
-+		 *  special variant which forces global-like behavior for matching.
-+		 */
-+
-+		DUK_ASSERT_TOP(ctx, 4);
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		if (is_regexp) {
-+			duk_dup(ctx, 0);
-+			duk_dup(ctx, 2);
-+			duk_regexp_match_force_global(thr);  /* [ ... regexp input ] -> [ res_obj ] */
-+			if (!duk_is_object(ctx, -1)) {
-+				duk_pop(ctx);
-+				break;
-+			}
-+			matched = 1;
-+
-+			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
-+			DUK_ASSERT(duk_is_number(ctx, -1));
-+			match_start_coff = duk_get_int(ctx, -1);
-+			match_start_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_start_coff);
-+			duk_pop(ctx);
-+
-+			if (match_start_coff == DUK_HSTRING_GET_CHARLEN(h_input)) {
-+				/* don't allow an empty match at the end of the string */
-+				duk_pop(ctx);
-+				break;
-+			}
-+
-+			duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-+			DUK_ASSERT(duk_is_number(ctx, -1));
-+			match_end_coff = duk_get_int(ctx, -1);
-+			match_end_boff = duk_heap_strcache_offset_char2byte(thr, h_input, match_end_coff);
-+			duk_pop(ctx);
-+
-+			/* empty match -> bump and continue */
-+			if (prev_match_end_boff == match_end_boff) {
-+				duk_push_int(ctx, match_end_coff + 1);
-+				duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-+				duk_pop(ctx);
-+				continue;
-+			}
-+		} else {
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+		{  /* unconditionally */
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+			const duk_uint8_t *p_start, *p_end, *p;   /* input string scan */
-+			const duk_uint8_t *q_start;               /* match string */
-+			duk_size_t q_blen, q_clen;
-+
-+			p_start = DUK_HSTRING_GET_DATA(h_input);
-+			p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
-+			p = p_start + prev_match_end_boff;
-+
-+			h_sep = duk_get_hstring(ctx, 0);
-+			DUK_ASSERT(h_sep != NULL);
-+			q_start = DUK_HSTRING_GET_DATA(h_sep);
-+			q_blen = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h_sep);
-+			q_clen = (duk_size_t) DUK_HSTRING_GET_CHARLEN(h_sep);
-+
-+			p_end -= q_blen;  /* ensure full memcmp() fits in while */
-+
-+			match_start_coff = prev_match_end_coff;
-+
-+			if (q_blen == 0) {
-+				/* Handle empty separator case: it will always match, and always
-+				 * triggers the check in step 13.c.iii initially.  Note that we
-+				 * must skip to either end of string or start of first codepoint,
-+				 * skipping over any continuation bytes!
-+				 *
-+				 * Don't allow an empty string to match at the end of the input.
-+				 */
-+
-+				matched = 1;  /* empty separator can always match */
-+
-+				match_start_coff++;
-+				p++;
-+				while (p < p_end) {
-+					if ((p[0] & 0xc0) != 0x80) {
-+						goto found;
-+					}
-+					p++;
-+				}
-+				goto not_found;
-+			}
-+
-+			DUK_ASSERT(q_blen > 0 && q_clen > 0);
-+			while (p <= p_end) {
-+				DUK_ASSERT(p + q_blen <= DUK_HSTRING_GET_DATA(h_input) + DUK_HSTRING_GET_BYTELEN(h_input));
-+				DUK_ASSERT(q_blen > 0);  /* no issues with empty memcmp() */
-+				if (DUK_MEMCMP((void *) p, (void *) q_start, (duk_size_t) q_blen) == 0) {
-+					/* never an empty match, so step 13.c.iii can't be triggered */
-+					goto found;
-+				}
-+
-+				/* track utf-8 non-continuation bytes */
-+				if ((p[0] & 0xc0) != 0x80) {
-+					match_start_coff++;
-+				}
-+				p++;
-+			}
-+
-+		 not_found:
-+			/* not found */
-+			break;
-+
-+		 found:
-+			matched = 1;
-+			match_start_boff = (duk_uint32_t) (p - p_start);
-+			match_end_coff = (duk_uint32_t) (match_start_coff + q_clen);  /* constrained by string length */
-+			match_end_boff = (duk_uint32_t) (match_start_boff + q_blen);  /* ditto */
-+
-+			/* empty match (may happen with empty separator) -> bump and continue */
-+			if (prev_match_end_boff == match_end_boff) {
-+				prev_match_end_boff++;
-+				prev_match_end_coff++;
-+				continue;
-+			}
-+		}  /* if (is_regexp) */
-+
-+		/* stack[0] = separator (string or regexp)
-+		 * stack[1] = limit
-+		 * stack[2] = input string
-+		 * stack[3] = result array
-+		 * stack[4] = regexp res_obj (if is_regexp)
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("split; match_start b=%ld,c=%ld, match_end b=%ld,c=%ld, prev_end b=%ld,c=%ld",
-+		                     (long) match_start_boff, (long) match_start_coff,
-+		                     (long) match_end_boff, (long) match_end_coff,
-+		                     (long) prev_match_end_boff, (long) prev_match_end_coff));
-+
-+		duk_push_lstring(ctx,
-+		                 (const char *) (DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff),
-+		                 (duk_size_t) (match_start_boff - prev_match_end_boff));
-+		duk_put_prop_index(ctx, 3, arr_idx);
-+		arr_idx++;
-+		if (arr_idx >= limit) {
-+			goto hit_limit;
-+		}
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		if (is_regexp) {
-+			duk_size_t i, len;
-+
-+			len = duk_get_length(ctx, 4);
-+			for (i = 1; i < len; i++) {
-+				DUK_ASSERT(i <= DUK_UARRIDX_MAX);  /* cannot have >4G captures */
-+				duk_get_prop_index(ctx, 4, (duk_uarridx_t) i);
-+				duk_put_prop_index(ctx, 3, arr_idx);
-+				arr_idx++;
-+				if (arr_idx >= limit) {
-+					goto hit_limit;
-+				}
-+			}
-+
-+			duk_pop(ctx);
-+			/* lastIndex already set up for next match */
-+		} else {
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+		{  /* unconditionally */
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+			/* no action */
-+		}
-+
-+		prev_match_end_boff = match_end_boff;
-+		prev_match_end_coff = match_end_coff;
-+		continue;
-+	}  /* for */
-+
-+	/* Combined step 11 (empty string special case) and 14-15. */
-+
-+	DUK_DDD(DUK_DDDPRINT("split trailer; prev_end b=%ld,c=%ld",
-+	                     (long) prev_match_end_boff, (long) prev_match_end_coff));
-+
-+	if (DUK_HSTRING_GET_CHARLEN(h_input) > 0 || !matched) {
-+		/* Add trailer if:
-+		 *   a) non-empty input
-+		 *   b) empty input and no (zero size) match found (step 11)
-+		 */
-+
-+		duk_push_lstring(ctx,
-+		                 (const char *) DUK_HSTRING_GET_DATA(h_input) + prev_match_end_boff,
-+		                 (duk_size_t) (DUK_HSTRING_GET_BYTELEN(h_input) - prev_match_end_boff));
-+		duk_put_prop_index(ctx, 3, arr_idx);
-+		/* No arr_idx update or limit check */
-+	}
-+
-+	return 1;
-+
-+ hit_limit:
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+	if (is_regexp) {
-+		duk_pop(ctx);
-+	}
-+#endif
-+
-+	return 1;
-+}
-+
-+/*
-+ *  Various
-+ */
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+DUK_LOCAL void duk__to_regexp_helper(duk_context *ctx, duk_idx_t index, duk_bool_t force_new) {
-+	duk_hobject *h;
-+
-+	/* Shared helper for match() steps 3-4, search() steps 3-4. */
-+
-+	DUK_ASSERT(index >= 0);
-+
-+	if (force_new) {
-+		goto do_new;
-+	}
-+
-+	h = duk_get_hobject_with_class(ctx, index, DUK_HOBJECT_CLASS_REGEXP);
-+	if (!h) {
-+		goto do_new;
-+	}
-+	return;
-+
-+ do_new:
-+	duk_push_hobject_bidx(ctx, DUK_BIDX_REGEXP_CONSTRUCTOR);
-+	duk_dup(ctx, index);
-+	duk_new(ctx, 1);  /* [ ... RegExp val ] -> [ ... res ] */
-+	duk_replace(ctx, index);
-+}
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+
-+	/* Easiest way to implement the search required by the specification
-+	 * is to do a RegExp test() with lastIndex forced to zero.  To avoid
-+	 * side effects on the argument, "clone" the RegExp if a RegExp was
-+	 * given as input.
-+	 *
-+	 * The global flag of the RegExp should be ignored; setting lastIndex
-+	 * to zero (which happens when "cloning" the RegExp) should have an
-+	 * equivalent effect.
-+	 */
-+
-+	DUK_ASSERT_TOP(ctx, 1);
-+	(void) duk_push_this_coercible_to_string(ctx);  /* at index 1 */
-+	duk__to_regexp_helper(ctx, 0 /*index*/, 1 /*force_new*/);
-+
-+	/* stack[0] = regexp
-+	 * stack[1] = string
-+	 */
-+
-+	/* Avoid using RegExp.prototype methods, as they're writable and
-+	 * configurable and may have been changed.
-+	 */
-+
-+	duk_dup(ctx, 0);
-+	duk_dup(ctx, 1);  /* [ ... re_obj input ] */
-+	duk_regexp_match(thr);  /* -> [ ... res_obj ] */
-+
-+	if (!duk_is_object(ctx, -1)) {
-+		duk_push_int(ctx, -1);
-+		return 1;
-+	}
-+
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INDEX);
-+	DUK_ASSERT(duk_is_number(ctx, -1));
-+	return 1;
-+}
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_search(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_bool_t global;
-+	duk_int_t prev_last_index;
-+	duk_int_t this_index;
-+	duk_int_t arr_idx;
-+
-+	DUK_ASSERT_TOP(ctx, 1);
-+	(void) duk_push_this_coercible_to_string(ctx);
-+	duk__to_regexp_helper(ctx, 0 /*index*/, 0 /*force_new*/);
-+	global = duk_get_prop_stridx_boolean(ctx, 0, DUK_STRIDX_GLOBAL, NULL);
-+	DUK_ASSERT_TOP(ctx, 2);
-+
-+	/* stack[0] = regexp
-+	 * stack[1] = string
-+	 */
-+
-+	if (!global) {
-+		duk_regexp_match(thr);  /* -> [ res_obj ] */
-+		return 1;  /* return 'res_obj' */
-+	}
-+
-+	/* Global case is more complex. */
-+
-+	/* [ regexp string ] */
-+
-+	duk_push_int(ctx, 0);
-+	duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-+	duk_push_array(ctx);
-+
-+	/* [ regexp string res_arr ] */
-+
-+	prev_last_index = 0;
-+	arr_idx = 0;
-+
-+	for (;;) {
-+		DUK_ASSERT_TOP(ctx, 3);
-+
-+		duk_dup(ctx, 0);
-+		duk_dup(ctx, 1);
-+		duk_regexp_match(thr);  /* -> [ ... regexp string ] -> [ ... res_obj ] */
-+
-+		if (!duk_is_object(ctx, -1)) {
-+			duk_pop(ctx);
-+			break;
-+		}
-+
-+		duk_get_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-+		DUK_ASSERT(duk_is_number(ctx, -1));
-+		this_index = duk_get_int(ctx, -1);
-+		duk_pop(ctx);
-+
-+		if (this_index == prev_last_index) {
-+			this_index++;
-+			duk_push_int(ctx, this_index);
-+			duk_put_prop_stridx(ctx, 0, DUK_STRIDX_LAST_INDEX);
-+		}
-+		prev_last_index = this_index;
-+
-+		duk_get_prop_index(ctx, -1, 0);  /* match string */
-+		duk_put_prop_index(ctx, 2, arr_idx);
-+		arr_idx++;
-+		duk_pop(ctx);  /* res_obj */
-+	}
-+
-+	if (arr_idx == 0) {
-+		duk_push_null(ctx);
-+	}
-+
-+	return 1;  /* return 'res_arr' or 'null' */
-+}
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_match(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_UNSUPPORTED_ERROR;
-+}
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_concat(duk_context *ctx) {
-+	/* duk_concat() coerces arguments with ToString() in correct order */
-+	(void) duk_push_this_coercible_to_string(ctx);
-+	duk_insert(ctx, 0);  /* this is relatively expensive */
-+	duk_concat(ctx, duk_get_top(ctx));
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_trim(duk_context *ctx) {
-+	DUK_ASSERT_TOP(ctx, 0);
-+	(void) duk_push_this_coercible_to_string(ctx);
-+	duk_trim(ctx, 0);
-+	DUK_ASSERT_TOP(ctx, 1);
-+	return 1;
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_string_prototype_locale_compare(duk_context *ctx) {
-+	duk_hstring *h1;
-+	duk_hstring *h2;
-+	duk_size_t h1_len, h2_len, prefix_len;
-+	duk_small_int_t ret = 0;
-+	duk_small_int_t rc;
-+
-+	/* The current implementation of localeCompare() is simply a codepoint
-+	 * by codepoint comparison, implemented with a simple string compare
-+	 * because UTF-8 should preserve codepoint ordering (assuming valid
-+	 * shortest UTF-8 encoding).
-+	 *
-+	 * The specification requires that the return value must be related
-+	 * to the sort order: e.g. negative means that 'this' comes before
-+	 * 'that' in sort order.  We assume an ascending sort order.
-+	 */
-+
-+	/* XXX: could share code with duk_js_ops.c, duk_js_compare_helper */
-+
-+	h1 = duk_push_this_coercible_to_string(ctx);
-+	DUK_ASSERT(h1 != NULL);
-+
-+	h2 = duk_to_hstring(ctx, 0);
-+	DUK_ASSERT(h2 != NULL);
-+
-+	h1_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h1);
-+	h2_len = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h2);
-+	prefix_len = (h1_len <= h2_len ? h1_len : h2_len);
-+
-+	/* Zero size compare not an issue with DUK_MEMCMP. */
-+	rc = (duk_small_int_t) DUK_MEMCMP((const char *) DUK_HSTRING_GET_DATA(h1),
-+	                                  (const char *) DUK_HSTRING_GET_DATA(h2),
-+	                                  prefix_len);
-+
-+	if (rc < 0) {
-+		ret = -1;
-+		goto done;
-+	} else if (rc > 0) {
-+		ret = 1;
-+		goto done;
-+	}
-+
-+	/* prefix matches, lengths matter now */
-+	if (h1_len > h2_len) {
-+		ret = 1;
-+		goto done;
-+	} else if (h1_len == h2_len) {
-+		DUK_ASSERT(ret == 0);
-+		goto done;
-+	}
-+	ret = -1;
-+	goto done;
-+
-+ done:
-+	duk_push_int(ctx, (duk_int_t) ret);
-+	return 1;
-+}
-+#line 1 "duk_bi_thread.c"
-+/*
-+ *  Thread builtins
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Constructor
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_thread_constructor(duk_context *ctx) {
-+	duk_hthread *new_thr;
-+	duk_hobject *func;
-+
-+	/* XXX: need a duk_require_func_or_lfunc_coerce() */
-+	if (!duk_is_callable(ctx, 0)) {
-+		return DUK_RET_TYPE_ERROR;
-+	}
-+	func = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-+	DUK_ASSERT(func != NULL);
-+
-+	duk_push_thread(ctx);
-+	new_thr = (duk_hthread *) duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(new_thr != NULL);
-+	new_thr->state = DUK_HTHREAD_STATE_INACTIVE;
-+
-+	/* push initial function call to new thread stack; this is
-+	 * picked up by resume().
-+	 */
-+	duk_push_hobject((duk_context *) new_thr, func);
-+
-+	return 1;  /* return thread */
-+}
-+
-+/*
-+ *  Resume a thread.
-+ *
-+ *  The thread must be in resumable state, either (a) new thread which hasn't
-+ *  yet started, or (b) a thread which has previously yielded.  This method
-+ *  must be called from an Ecmascript function.
-+ *
-+ *  Args:
-+ *    - thread
-+ *    - value
-+ *    - isError (defaults to false)
-+ *
-+ *  Note: yield and resume handling is currently asymmetric.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_thread_resume(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hthread *thr_resume;
-+	duk_tval tv_tmp;
-+	duk_tval *tv;
-+	duk_hobject *func;
-+	duk_hobject *caller_func;
-+	duk_small_int_t is_error;
-+
-+	DUK_DDD(DUK_DDDPRINT("Duktape.Thread.resume(): thread=%!T, value=%!T, is_error=%!T",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 1),
-+	                     (duk_tval *) duk_get_tval(ctx, 2)));
-+
-+	DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
-+	DUK_ASSERT(thr->heap->curr_thread == thr);
-+
-+	thr_resume = duk_require_hthread(ctx, 0);
-+	is_error = (duk_small_int_t) duk_to_boolean(ctx, 2);
-+	duk_set_top(ctx, 2);
-+
-+	/* [ thread value ] */
-+
-+	/*
-+	 *  Thread state and calling context checks
-+	 */
-+
-+	if (thr->callstack_top < 2) {
-+		DUK_DD(DUK_DDPRINT("resume state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.resume)"));
-+		goto state_error;
-+	}
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);  /* us */
-+	DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL);  /* caller */
-+
-+	caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
-+	if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
-+		DUK_DD(DUK_DDPRINT("resume state invalid: caller must be Ecmascript code"));
-+		goto state_error;
-+	}
-+
-+	/* Note: there is no requirement that: 'thr->callstack_preventcount == 1'
-+	 * like for yield.
-+	 */
-+
-+	if (thr_resume->state != DUK_HTHREAD_STATE_INACTIVE &&
-+	    thr_resume->state != DUK_HTHREAD_STATE_YIELDED) {
-+		DUK_DD(DUK_DDPRINT("resume state invalid: target thread must be INACTIVE or YIELDED"));
-+		goto state_error;
-+	}
-+
-+	DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE ||
-+	           thr_resume->state == DUK_HTHREAD_STATE_YIELDED);
-+
-+	/* Further state-dependent pre-checks */
-+
-+	if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
-+		/* no pre-checks now, assume a previous yield() has left things in
-+		 * tip-top shape (longjmp handler will assert for these).
-+		 */
-+	} else {
-+		DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE);
-+
-+		if ((thr_resume->callstack_top != 0) ||
-+		    (thr_resume->valstack_top - thr_resume->valstack != 1)) {
-+			goto state_invalid_initial;
-+		}
-+		tv = &thr_resume->valstack_top[-1];
-+		DUK_ASSERT(tv >= thr_resume->valstack && tv < thr_resume->valstack_top);
-+		if (!DUK_TVAL_IS_OBJECT(tv)) {
-+			goto state_invalid_initial;
-+		}
-+		func = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(func != NULL);
-+		if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-+			/* Note: cannot be a bound function either right now,
-+			 * this would be easy to relax though.
-+			 */
-+			goto state_invalid_initial;
-+		}
-+
-+	}
-+
-+	/*
-+	 *  The error object has been augmented with a traceback and other
-+	 *  info from its creation point -- usually another thread.  The
-+	 *  error handler is called here right before throwing, but it also
-+	 *  runs in the resumer's thread.  It might be nice to get a traceback
-+	 *  from the resumee but this is not the case now.
-+	 */
-+
-+#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-+	if (is_error) {
-+		DUK_ASSERT_TOP(ctx, 2);  /* value (error) is at stack top */
-+		duk_err_augment_error_throw(thr);  /* in resumer's context */
-+	}
-+#endif
-+
-+#ifdef DUK_USE_DEBUG
-+	if (is_error) {
-+		DUK_DDD(DUK_DDDPRINT("RESUME ERROR: thread=%!T, value=%!T",
-+		                     (duk_tval *) duk_get_tval(ctx, 0),
-+		                     (duk_tval *) duk_get_tval(ctx, 1)));
-+	} else if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
-+		DUK_DDD(DUK_DDDPRINT("RESUME NORMAL: thread=%!T, value=%!T",
-+		                     (duk_tval *) duk_get_tval(ctx, 0),
-+		                     (duk_tval *) duk_get_tval(ctx, 1)));
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("RESUME INITIAL: thread=%!T, value=%!T",
-+		                     (duk_tval *) duk_get_tval(ctx, 0),
-+		                     (duk_tval *) duk_get_tval(ctx, 1)));
-+	}
-+#endif
-+
-+	thr->heap->lj.type = DUK_LJ_TYPE_RESUME;
-+
-+	/* lj value2: thread */
-+	DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2);
-+	DUK_TVAL_SET_TVAL(&thr->heap->lj.value2, &thr->valstack_bottom[0]);
-+	DUK_TVAL_INCREF(thr, &thr->heap->lj.value2);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+	/* lj value1: value */
-+	DUK_ASSERT(thr->valstack_bottom + 1 < thr->valstack_top);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1);
-+	DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, &thr->valstack_bottom[1]);
-+	DUK_TVAL_INCREF(thr, &thr->heap->lj.value1);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+	thr->heap->lj.iserror = is_error;
-+
-+	DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* call is from executor, so we know we have a jmpbuf */
-+	duk_err_longjmp(thr);  /* execution resumes in bytecode executor */
-+	return 0;  /* never here */
-+
-+ state_invalid_initial:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid initial thread state/stack");
-+	return 0;  /* never here */
-+
-+ state_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid state for resume");
-+	return 0;  /* never here */
-+}
-+
-+/*
-+ *  Yield the current thread.
-+ *
-+ *  The thread must be in yieldable state: it must have a resumer, and there
-+ *  must not be any yield-preventing calls (native calls and constructor calls,
-+ *  currently) in the thread's call stack (otherwise a resume would not be
-+ *  possible later).  This method must be called from an Ecmascript function.
-+ *
-+ *  Args:
-+ *    - value
-+ *    - isError (defaults to false)
-+ *
-+ *  Note: yield and resume handling is currently asymmetric.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_thread_yield(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval tv_tmp;
-+	duk_hobject *caller_func;
-+	duk_small_int_t is_error;
-+
-+	DUK_DDD(DUK_DDDPRINT("Duktape.Thread.yield(): value=%!T, is_error=%!T",
-+	                     (duk_tval *) duk_get_tval(ctx, 0),
-+	                     (duk_tval *) duk_get_tval(ctx, 1)));
-+
-+	DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
-+	DUK_ASSERT(thr->heap->curr_thread == thr);
-+
-+	is_error = (duk_small_int_t) duk_to_boolean(ctx, 1);
-+	duk_set_top(ctx, 1);
-+
-+	/* [ value ] */
-+
-+	/*
-+	 *  Thread state and calling context checks
-+	 */
-+
-+	if (!thr->resumer) {
-+		DUK_DD(DUK_DDPRINT("yield state invalid: current thread must have a resumer"));
-+		goto state_error;
-+	}
-+	DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED);
-+
-+	if (thr->callstack_top < 2) {
-+		DUK_DD(DUK_DDPRINT("yield state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.yield)"));
-+		goto state_error;
-+	}
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);  /* us */
-+	DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL);  /* caller */
-+
-+	caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
-+	if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
-+		DUK_DD(DUK_DDPRINT("yield state invalid: caller must be Ecmascript code"));
-+		goto state_error;
-+	}
-+
-+	DUK_ASSERT(thr->callstack_preventcount >= 1);  /* should never be zero, because we (Duktape.Thread.yield) are on the stack */
-+	if (thr->callstack_preventcount != 1) {
-+		/* Note: the only yield-preventing call is Duktape.Thread.yield(), hence check for 1, not 0 */
-+		DUK_DD(DUK_DDPRINT("yield state invalid: there must be no yield-preventing calls in current thread callstack (preventcount is %ld)",
-+		                   (long) thr->callstack_preventcount));
-+		goto state_error;
-+	}
-+
-+	/*
-+	 *  The error object has been augmented with a traceback and other
-+	 *  info from its creation point -- usually the current thread.
-+	 *  The error handler, however, is called right before throwing
-+	 *  and runs in the yielder's thread.
-+	 */
-+
-+#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-+	if (is_error) {
-+		DUK_ASSERT_TOP(ctx, 1);  /* value (error) is at stack top */
-+		duk_err_augment_error_throw(thr);  /* in yielder's context */
-+	}
-+#endif
-+
-+#ifdef DUK_USE_DEBUG
-+	if (is_error) {
-+		DUK_DDD(DUK_DDDPRINT("YIELD ERROR: value=%!T",
-+		                     (duk_tval *) duk_get_tval(ctx, 0)));
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("YIELD NORMAL: value=%!T",
-+		                     (duk_tval *) duk_get_tval(ctx, 0)));
-+	}
-+#endif
-+
-+	/*
-+	 *  Process yield
-+	 *
-+	 *  After longjmp(), processing continues in bytecode executor longjmp
-+	 *  handler, which will e.g. update thr->resumer to NULL.
-+	 */
-+
-+	thr->heap->lj.type = DUK_LJ_TYPE_YIELD;
-+
-+	/* lj value1: value */
-+	DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1);
-+	DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, &thr->valstack_bottom[0]);
-+	DUK_TVAL_INCREF(thr, &thr->heap->lj.value1);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+	thr->heap->lj.iserror = is_error;
-+
-+	DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* call is from executor, so we know we have a jmpbuf */
-+	duk_err_longjmp(thr);  /* execution resumes in bytecode executor */
-+	return 0;  /* never here */
-+
-+ state_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid state for yield");
-+	return 0;  /* never here */
-+}
-+
-+DUK_INTERNAL duk_ret_t duk_bi_thread_current(duk_context *ctx) {
-+	duk_push_current_thread(ctx);
-+	return 1;
-+}
-+#line 1 "duk_bi_thrower.c"
-+/*
-+ *  Type error thrower, E5 Section 13.2.3.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL duk_ret_t duk_bi_type_error_thrower(duk_context *ctx) {
-+	DUK_UNREF(ctx);
-+	return DUK_RET_TYPE_ERROR;
-+}
-+#line 1 "duk_debug_fixedbuffer.c"
-+/*
-+ *  Fixed buffer helper useful for debugging, requires no allocation
-+ *  which is critical for debugging.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_DEBUG
-+
-+DUK_INTERNAL void duk_fb_put_bytes(duk_fixedbuffer *fb, duk_uint8_t *buffer, duk_size_t length) {
-+	duk_size_t avail;
-+	duk_size_t copylen;
-+
-+	avail = (fb->offset >= fb->length ? (duk_size_t) 0 : (duk_size_t) (fb->length - fb->offset));
-+	if (length > avail) {
-+		copylen = avail;
-+		fb->truncated = 1;
-+	} else {
-+		copylen = length;
-+	}
-+	DUK_MEMCPY(fb->buffer + fb->offset, buffer, copylen);
-+	fb->offset += copylen;
-+}
-+
-+DUK_INTERNAL void duk_fb_put_byte(duk_fixedbuffer *fb, duk_uint8_t x) {
-+	duk_fb_put_bytes(fb, &x, 1);
-+}
-+
-+DUK_INTERNAL void duk_fb_put_cstring(duk_fixedbuffer *fb, const char *x) {
-+	duk_fb_put_bytes(fb, (duk_uint8_t *) x, (duk_size_t) DUK_STRLEN(x));
-+}
-+
-+DUK_INTERNAL void duk_fb_sprintf(duk_fixedbuffer *fb, const char *fmt, ...) {
-+	duk_size_t avail;
-+	va_list ap;
-+
-+	va_start(ap, fmt);
-+	avail = (fb->offset >= fb->length ? (duk_size_t) 0 : (duk_size_t) (fb->length - fb->offset));
-+	if (avail > 0) {
-+		duk_int_t res = (duk_int_t) DUK_VSNPRINTF((char *) (fb->buffer + fb->offset), avail, fmt, ap);
-+		if (res < 0) {
-+			/* error */
-+		} else if ((duk_size_t) res >= avail) {
-+			/* (maybe) truncated */
-+			fb->offset += avail;
-+			if ((duk_size_t) res > avail) {
-+				/* actual chars dropped (not just NUL term) */
-+				fb->truncated = 1;
-+			}
-+		} else {
-+			/* normal */
-+			fb->offset += res;
-+		}
-+	}
-+	va_end(ap);
-+}
-+
-+DUK_INTERNAL void duk_fb_put_funcptr(duk_fixedbuffer *fb, duk_uint8_t *fptr, duk_size_t fptr_size) {
-+	char buf[64+1];
-+	duk_debug_format_funcptr(buf, sizeof(buf), fptr, fptr_size);
-+	buf[sizeof(buf) - 1] = (char) 0;
-+	duk_fb_put_cstring(fb, buf);
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_fb_is_full(duk_fixedbuffer *fb) {
-+	return (fb->offset >= fb->length);
-+}
-+
-+#endif  /* DUK_USE_DEBUG */
-+#line 1 "duk_debug_heap.c"
-+/*
-+ *  Debug dumping of duk_heap.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_DEBUG
-+
-+#if 0  /*unused*/
-+DUK_LOCAL void duk__sanitize_snippet(char *buf, duk_size_t buf_size, duk_hstring *str) {
-+	duk_size_t i;
-+	duk_size_t nchars;
-+	duk_size_t maxchars;
-+	duk_uint8_t *data;
-+
-+	DUK_MEMZERO(buf, buf_size);
-+
-+	maxchars = (duk_size_t) (buf_size - 1);
-+	data = DUK_HSTRING_GET_DATA(str);
-+	nchars = ((duk_size_t) str->blen < maxchars ? (duk_size_t) str->blen : maxchars);
-+	for (i = 0; i < nchars; i++) {
-+		duk_small_int_t c = (duk_small_int_t) data[i];
-+		if (c < 0x20 || c > 0x7e) {
-+			c = '.';
-+		}
-+		buf[i] = (char) c;
-+	}
-+}
-+#endif
-+
-+#if 0
-+DUK_LOCAL const char *duk__get_heap_type_string(duk_heaphdr *hdr) {
-+	switch (DUK_HEAPHDR_GET_TYPE(hdr)) {
-+	case DUK_HTYPE_STRING:
-+		return "string";
-+	case DUK_HTYPE_OBJECT:
-+		return "object";
-+	case DUK_HTYPE_BUFFER:
-+		return "buffer";
-+	default:
-+		return "???";
-+	}
-+}
-+#endif
-+
-+#if 0
-+DUK_LOCAL void duk__dump_indented(duk_heaphdr *obj, int index) {
-+	DUK_UNREF(obj);
-+	DUK_UNREF(index);
-+	DUK_UNREF(duk__get_heap_type_string);
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	DUK_D(DUK_DPRINT("  [%ld]: %p %s (flags: 0x%08lx, ref: %ld) -> %!O",
-+	                 (long) index,
-+	                 (void *) obj,
-+	                 (const char *) duk__get_heap_type_string(obj),
-+	                 (unsigned long) DUK_HEAPHDR_GET_FLAGS(obj),
-+	                 (long) DUK_HEAPHDR_GET_REFCOUNT(obj),
-+	                 (duk_heaphdr *) obj));
-+#else
-+	DUK_D(DUK_DPRINT("  [%ld]: %p %s (flags: 0x%08lx) -> %!O",
-+	                 (long) index,
-+	                 (void *) obj,
-+	                 (const char *) duk__get_heap_type_string(obj),
-+	                 (unsigned long) DUK_HEAPHDR_GET_FLAGS(obj),
-+	                 (duk_heaphdr *) obj));
-+#endif
-+}
-+#endif
-+
-+#if 0  /*unused*/
-+DUK_LOCAL void duk__dump_heaphdr_list(duk_heap *heap, duk_heaphdr *root, const char *name) {
-+	duk_int_t count;
-+	duk_heaphdr *curr;
-+
-+	DUK_UNREF(heap);
-+	DUK_UNREF(name);
-+
-+	count = 0;
-+	curr = root;
-+	while (curr) {
-+		count++;
-+		curr = DUK_HEAPHDR_GET_NEXT(curr);
-+	}
-+
-+	DUK_D(DUK_DPRINT("%s, %ld objects", (const char *) name, (long) count));
-+
-+	count = 0;
-+	curr = root;
-+	while (curr) {
-+		count++;
-+		duk__dump_indented(curr, count);
-+		curr = DUK_HEAPHDR_GET_NEXT(curr);
-+	}
-+}
-+#endif
-+
-+#if 0  /*unused*/
-+DUK_LOCAL void duk__dump_stringtable(duk_heap *heap) {
-+	duk_uint_fast32_t i;
-+	char buf[64+1];
-+
-+	DUK_D(DUK_DPRINT("stringtable %p, used %ld, size %ld, load %ld%%",
-+	                 (void *) heap->strtable,
-+	                 (long) heap->st_used,
-+	                 (long) heap->st_size,
-+	                 (long) (((double) heap->st_used) / ((double) heap->st_size) * 100.0)));
-+
-+	for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
-+		duk_hstring *e = heap->strtable[i];
-+
-+		if (!e) {
-+			DUK_D(DUK_DPRINT("  [%ld]: NULL", (long) i));
-+		} else if (e == DUK_STRTAB_DELETED_MARKER(heap)) {
-+			DUK_D(DUK_DPRINT("  [%ld]: DELETED", (long) i));
-+		} else {
-+			duk__sanitize_snippet(buf, sizeof(buf), e);
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+			DUK_D(DUK_DPRINT("  [%ld]: %p (flags: 0x%08lx, ref: %ld) '%s', strhash=0x%08lx, blen=%ld, clen=%ld, "
-+			                 "arridx=%ld, internal=%ld, reserved_word=%ld, strict_reserved_word=%ld, eval_or_arguments=%ld",
-+			                 (long) i,
-+			                 (void *) e,
-+			                 (unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
-+			                 (long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) e),
-+			                 (const char *) buf,
-+			                 (unsigned long) e->hash,
-+			                 (long) e->blen,
-+			                 (long) e->clen,
-+			                 (long) (DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0),
-+			                 (long) (DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0),
-+			                 (long) (DUK_HSTRING_HAS_RESERVED_WORD(e) ? 1 : 0),
-+			                 (long) (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(e) ? 1 : 0),
-+			                 (long) (DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(e) ? 1 : 0)));
-+#else
-+			DUK_D(DUK_DPRINT("  [%ld]: %p (flags: 0x%08lx) '%s', strhash=0x%08lx, blen=%ld, clen=%ld, "
-+			                 "arridx=%ld, internal=%ld, reserved_word=%ld, strict_reserved_word=%ld, eval_or_arguments=%ld",
-+			                 (long) i,
-+			                 (void *) e,
-+			                 (unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) e),
-+			                 (const char *) buf,
-+			                 (long) e->hash,
-+			                 (long) e->blen,
-+			                 (long) e->clen,
-+			                 (long) (DUK_HSTRING_HAS_ARRIDX(e) ? 1 : 0),
-+			                 (long) (DUK_HSTRING_HAS_INTERNAL(e) ? 1 : 0),
-+			                 (long) (DUK_HSTRING_HAS_RESERVED_WORD(e) ? 1 : 0),
-+			                 (long) (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(e) ? 1 : 0),
-+			                 (long) (DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(e) ? 1 : 0)));
-+#endif
-+		}
-+	}
-+}
-+#endif
-+
-+#if 0  /*unused*/
-+DUK_LOCAL void duk__dump_strcache(duk_heap *heap) {
-+	duk_uint_fast32_t i;
-+	char buf[64+1];
-+
-+	DUK_D(DUK_DPRINT("stringcache"));
-+
-+	for (i = 0; i < (duk_uint_fast32_t) DUK_HEAP_STRCACHE_SIZE; i++) {
-+		duk_strcache *c = &heap->strcache[i];
-+		if (!c->h) {
-+			DUK_D(DUK_DPRINT("  [%ld]: bidx=%ld, cidx=%ld, str=NULL",
-+			                 (long) i, (long) c->bidx, (long) c->cidx));
-+		} else {
-+			duk__sanitize_snippet(buf, sizeof(buf), c->h);
-+			DUK_D(DUK_DPRINT("  [%ld]: bidx=%ld cidx=%ld str=%s",
-+			                 (long) i, (long) c->bidx, (long) c->cidx, (const char *) buf));
-+		}
-+	}
-+}
-+#endif
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL void duk_debug_dump_heap(duk_heap *heap) {
-+	char buf[64+1];
-+
-+	DUK_D(DUK_DPRINT("=== heap %p ===", (void *) heap));
-+	DUK_D(DUK_DPRINT("  flags: 0x%08lx", (unsigned long) heap->flags));
-+
-+	/* Note: there is no standard formatter for function pointers */
-+#ifdef DUK_USE_GCC_PRAGMAS
-+#pragma GCC diagnostic push
-+#pragma GCC diagnostic ignored "-pedantic"
-+#endif
-+	duk_debug_format_funcptr(buf, sizeof(buf), (duk_uint8_t *) &heap->alloc_func, sizeof(heap->alloc_func));
-+	DUK_D(DUK_DPRINT("  alloc_func: %s", (const char *) buf));
-+	duk_debug_format_funcptr(buf, sizeof(buf), (duk_uint8_t *) &heap->realloc_func, sizeof(heap->realloc_func));
-+	DUK_D(DUK_DPRINT("  realloc_func: %s", (const char *) buf));
-+	duk_debug_format_funcptr(buf, sizeof(buf), (duk_uint8_t *) &heap->free_func, sizeof(heap->free_func));
-+	DUK_D(DUK_DPRINT("  free_func: %s", (const char *) buf));
-+	duk_debug_format_funcptr(buf, sizeof(buf), (duk_uint8_t *) &heap->fatal_func, sizeof(heap->fatal_func));
-+	DUK_D(DUK_DPRINT("  fatal_func: %s", (const char *) buf));
-+#ifdef DUK_USE_GCC_PRAGMAS
-+#pragma GCC diagnostic pop
-+#endif
-+
-+	DUK_D(DUK_DPRINT("  heap_udata: %p", (void *) heap->heap_udata));
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+#ifdef DUK_USE_VOLUNTARY_GC
-+	DUK_D(DUK_DPRINT("  mark-and-sweep trig counter: %ld", (long) heap->mark_and_sweep_trigger_counter));
-+#endif
-+	DUK_D(DUK_DPRINT("  mark-and-sweep rec depth: %ld", (long) heap->mark_and_sweep_recursion_depth));
-+	DUK_D(DUK_DPRINT("  mark-and-sweep base flags: 0x%08lx", (unsigned long) heap->mark_and_sweep_base_flags));
-+#endif
-+
-+	DUK_D(DUK_DPRINT("  lj.jmpbuf_ptr: %p", (void *) heap->lj.jmpbuf_ptr));
-+	DUK_D(DUK_DPRINT("  lj.type: %ld", (long) heap->lj.type));
-+	DUK_D(DUK_DPRINT("  lj.value1: %!T", (duk_tval *) &heap->lj.value1));
-+	DUK_D(DUK_DPRINT("  lj.value2: %!T", (duk_tval *) &heap->lj.value2));
-+	DUK_D(DUK_DPRINT("  lj.iserror: %ld", (long) heap->lj.iserror));
-+
-+	DUK_D(DUK_DPRINT("  handling_error: %ld", (long) heap->handling_error));
-+
-+	DUK_D(DUK_DPRINT("  heap_thread: %!@O", (duk_heaphdr *) heap->heap_thread));
-+	DUK_D(DUK_DPRINT("  curr_thread: %!@O", (duk_heaphdr *) heap->curr_thread));
-+	DUK_D(DUK_DPRINT("  heap_object: %!@O", (duk_heaphdr *) heap->heap_object));
-+
-+	DUK_D(DUK_DPRINT("  call_recursion_depth: %ld", (long) heap->call_recursion_depth));
-+	DUK_D(DUK_DPRINT("  call_recursion_limit: %ld", (long) heap->call_recursion_limit));
-+
-+	DUK_D(DUK_DPRINT("  hash_seed: 0x%08lx", (unsigned long) heap->hash_seed));
-+	DUK_D(DUK_DPRINT("  rnd_state: 0x%08lx", (unsigned long) heap->rnd_state));
-+
-+	duk__dump_strcache(heap);
-+
-+	duk__dump_heaphdr_list(heap, heap->heap_allocated, "heap allocated");
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk__dump_heaphdr_list(heap, heap->refzero_list, "refcounting refzero list");
-+#endif
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	duk__dump_heaphdr_list(heap, heap->finalize_list, "mark-and-sweep finalize list");
-+#endif
-+
-+	duk__dump_stringtable(heap);
-+
-+	/* heap->strs: not worth dumping */
-+}
-+#endif
-+
-+#endif  /* DUK_USE_DEBUG */
-+#line 1 "duk_debug_vsnprintf.c"
-+/*
-+ *  Custom formatter for debug printing, allowing Duktape specific data
-+ *  structures (such as tagged values and heap objects) to be printed with
-+ *  a nice format string.  Because debug printing should not affect execution
-+ *  state, formatting here must be independent of execution (see implications
-+ *  below) and must not allocate memory.
-+ *
-+ *  Custom format tags begin with a '%!' to safely distinguish them from
-+ *  standard format tags.  The following conversions are supported:
-+ *
-+ *     %!T    tagged value (duk_tval *)
-+ *     %!O    heap object (duk_heaphdr *)
-+ *     %!I    decoded bytecode instruction
-+ *     %!C    bytecode instruction opcode name (arg is long)
-+ *
-+ *  Everything is serialized in a JSON-like manner.  The default depth is one
-+ *  level, internal prototype is not followed, and internal properties are not
-+ *  serialized.  The following modifiers change this behavior:
-+ *
-+ *     @      print pointers
-+ *     #      print binary representations (where applicable)
-+ *     d      deep traversal of own properties (not prototype)
-+ *     p      follow prototype chain (useless without 'd')
-+ *     i      include internal properties (other than prototype)
-+ *     x      hexdump buffers
-+ *     h      heavy formatting
-+ *
-+ *  For instance, the following serializes objects recursively, but does not
-+ *  follow the prototype chain nor print internal properties: "%!dO".
-+ *
-+ *  Notes:
-+ *
-+ *    * Standard snprintf return value semantics seem to vary.  This
-+ *      implementation returns the number of bytes it actually wrote
-+ *      (excluding the null terminator).  If retval == buffer size,
-+ *      output was truncated (except for corner cases).
-+ *
-+ *    * Output format is intentionally different from Ecmascript
-+ *      formatting requirements, as formatting here serves debugging
-+ *      of internals.
-+ *
-+ *    * Depth checking (and updating) is done in each type printer
-+ *      separately, to allow them to call each other freely.
-+ *
-+ *    * Some pathological structures might take ages to print (e.g.
-+ *      self recursion with 100 properties pointing to the object
-+ *      itself).  To guard against these, each printer also checks
-+ *      whether the output buffer is full; if so, early exit.
-+ *
-+ *    * Reference loops are detected using a loop stack.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_DEBUG
-+
-+#include <stdio.h>
-+#include <stdarg.h>
-+#include <string.h>
-+
-+/* list of conversion specifiers that terminate a format tag;
-+ * this is unfortunately guesswork.
-+ */
-+#define DUK__ALLOWED_STANDARD_SPECIFIERS  "diouxXeEfFgGaAcsCSpnm"
-+
-+/* maximum length of standard format tag that we support */
-+#define DUK__MAX_FORMAT_TAG_LENGTH  32
-+
-+/* heapobj recursion depth when deep printing is selected */
-+#define DUK__DEEP_DEPTH_LIMIT  8
-+
-+/* maximum recursion depth for loop detection stacks */
-+#define DUK__LOOP_STACK_DEPTH  256
-+
-+/* must match bytecode defines now; build autogenerate? */
-+DUK_LOCAL const char *duk__bc_optab[64] = {
-+	"LDREG",    "STREG",    "LDCONST",  "LDINT",    "LDINTX",   "MPUTOBJ",  "MPUTOBJI", "MPUTARR",  "MPUTARRI", "NEW",
-+	"NEWI",     "REGEXP",   "CSREG",    "CSREGI",   "GETVAR",   "PUTVAR",   "DECLVAR",  "DELVAR",   "CSVAR",    "CSVARI",
-+	"CLOSURE",  "GETPROP",  "PUTPROP",  "DELPROP",  "CSPROP",   "CSPROPI",  "ADD",      "SUB",      "MUL",      "DIV",
-+	"MOD",      "BAND",     "BOR",      "BXOR",     "BASL",     "BLSR",     "BASR",     "EQ",       "NEQ",      "SEQ",
-+	"SNEQ",     "GT",       "GE",       "LT",       "LE",       "IF",       "JUMP",     "RETURN",   "CALL",     "CALLI",
-+	"TRYCATCH", "EXTRA",    "PREINCR",  "PREDECR",  "POSTINCR", "POSTDECR", "PREINCV",  "PREDECV",  "POSTINCV", "POSTDECV",
-+	"PREINCP",  "PREDECP",  "POSTINCP", "POSTDECP"
-+};
-+
-+DUK_LOCAL const char *duk__bc_extraoptab[256] = {
-+	"NOP", "INVALID", "LDTHIS", "LDUNDEF", "LDNULL", "LDTRUE", "LDFALSE", "NEWOBJ", "NEWARR", "SETALEN",
-+	"TYPEOF", "TYPEOFID", "INITENUM", "NEXTENUM", "INITSET", "INITSETI", "INITGET", "INITGETI", "ENDTRY", "ENDCATCH",
-+	"ENDFIN", "THROW", "INVLHS", "UNM", "UNP", "DEBUGGER", "BREAK", "CONTINUE", "BNOT", "LNOT",
-+	"INSTOF", "IN", "LABEL", "ENDLABEL", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX", "XXX",
-+
-+	"XXX", "XXX", "XXX", "XXX", "XXX", "XXX"
-+};
-+
-+typedef struct duk__dprint_state duk__dprint_state;
-+struct duk__dprint_state {
-+	duk_fixedbuffer *fb;
-+
-+	/* loop_stack_index could be perhaps be replaced by 'depth', but it's nice
-+	 * to not couple these two mechanisms unnecessarily.
-+	 */
-+	duk_hobject *loop_stack[DUK__LOOP_STACK_DEPTH];
-+	duk_int_t loop_stack_index;
-+	duk_int_t loop_stack_limit;
-+
-+	duk_int_t depth;
-+	duk_int_t depth_limit;
-+
-+	duk_bool_t pointer;
-+	duk_bool_t heavy;
-+	duk_bool_t binary;
-+	duk_bool_t follow_proto;
-+	duk_bool_t internal;
-+	duk_bool_t hexdump;
-+};
-+
-+/* helpers */
-+DUK_LOCAL_DECL void duk__print_hstring(duk__dprint_state *st, duk_hstring *k, duk_bool_t quotes);
-+DUK_LOCAL_DECL void duk__print_hobject(duk__dprint_state *st, duk_hobject *h);
-+DUK_LOCAL_DECL void duk__print_hbuffer(duk__dprint_state *st, duk_hbuffer *h);
-+DUK_LOCAL_DECL void duk__print_tval(duk__dprint_state *st, duk_tval *tv);
-+DUK_LOCAL_DECL void duk__print_instr(duk__dprint_state *st, duk_instr_t ins);
-+DUK_LOCAL_DECL void duk__print_heaphdr(duk__dprint_state *st, duk_heaphdr *h);
-+DUK_LOCAL_DECL void duk__print_shared_heaphdr(duk__dprint_state *st, duk_heaphdr *h);
-+DUK_LOCAL_DECL void duk__print_shared_heaphdr_string(duk__dprint_state *st, duk_heaphdr_string *h);
-+
-+DUK_LOCAL void duk__print_shared_heaphdr(duk__dprint_state *st, duk_heaphdr *h) {
-+	duk_fixedbuffer *fb = st->fb;
-+
-+	if (st->heavy) {
-+		duk_fb_sprintf(fb, "(%p)", (void *) h);
-+	}
-+
-+	if (!h) {
-+		return;
-+	}
-+
-+	if (st->binary) {
-+		duk_size_t i;
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LBRACKET);
-+		for (i = 0; i < (duk_size_t) sizeof(*h); i++) {
-+			duk_fb_sprintf(fb, "%02lx", (unsigned long) ((duk_uint8_t *)h)[i]);
-+		}
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RBRACKET);
-+	}
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING  /* currently implicitly also DUK_USE_DOUBLE_LINKED_HEAP */
-+	if (st->heavy) {
-+		duk_fb_sprintf(fb, "[h_next=%p,h_prev=%p,h_refcount=%lu,h_flags=%08lx,type=%ld,"
-+		               "reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]",
-+		               (void *) DUK_HEAPHDR_GET_NEXT(NULL, h),
-+		               (void *) DUK_HEAPHDR_GET_PREV(NULL, h),
-+		               (unsigned long) DUK_HEAPHDR_GET_REFCOUNT(h),
-+		               (unsigned long) DUK_HEAPHDR_GET_FLAGS(h),
-+		               (long) DUK_HEAPHDR_GET_TYPE(h),
-+		               (long) (DUK_HEAPHDR_HAS_REACHABLE(h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_TEMPROOT(h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_FINALIZABLE(h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_FINALIZED(h) ? 1 : 0));
-+	}
-+#else
-+	if (st->heavy) {
-+		duk_fb_sprintf(fb, "[h_next=%p,h_flags=%08lx,type=%ld,reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]",
-+		               (void *) DUK_HEAPHDR_GET_NEXT(NULL, h),
-+		               (unsigned long) DUK_HEAPHDR_GET_FLAGS(h),
-+		               (long) DUK_HEAPHDR_GET_TYPE(h),
-+		               (long) (DUK_HEAPHDR_HAS_REACHABLE(h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_TEMPROOT(h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_FINALIZABLE(h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_FINALIZED(h) ? 1 : 0));
-+	}
-+#endif
-+}
-+
-+DUK_LOCAL void duk__print_shared_heaphdr_string(duk__dprint_state *st, duk_heaphdr_string *h) {
-+	duk_fixedbuffer *fb = st->fb;
-+
-+	if (st->heavy) {
-+		duk_fb_sprintf(fb, "(%p)", (void *) h);
-+	}
-+
-+	if (!h) {
-+		return;
-+	}
-+
-+	if (st->binary) {
-+		duk_size_t i;
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LBRACKET);
-+		for (i = 0; i < (duk_size_t) sizeof(*h); i++) {
-+			duk_fb_sprintf(fb, "%02lx", (unsigned long) ((duk_uint8_t *)h)[i]);
-+		}
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RBRACKET);
-+	}
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	if (st->heavy) {
-+		duk_fb_sprintf(fb, "[h_refcount=%lu,h_flags=%08lx,type=%ld,reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]",
-+		               (unsigned long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h),
-+		               (unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) h),
-+		               (long) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h),
-+		               (long) (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_TEMPROOT((duk_heaphdr *) h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_FINALIZABLE((duk_heaphdr *) h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) h) ? 1 : 0));
-+	}
-+#else
-+	if (st->heavy) {
-+		duk_fb_sprintf(fb, "[h_flags=%08lx,type=%ld,reachable=%ld,temproot=%ld,finalizable=%ld,finalized=%ld]",
-+		               (unsigned long) DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) h),
-+		               (long) DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h),
-+		               (long) (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_TEMPROOT((duk_heaphdr *) h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_FINALIZABLE((duk_heaphdr *) h) ? 1 : 0),
-+		               (long) (DUK_HEAPHDR_HAS_FINALIZED((duk_heaphdr *) h) ? 1 : 0));
-+	}
-+#endif
-+}
-+
-+DUK_LOCAL void duk__print_hstring(duk__dprint_state *st, duk_hstring *h, duk_bool_t quotes) {
-+	duk_fixedbuffer *fb = st->fb;
-+	const duk_uint8_t *p;
-+	const duk_uint8_t *p_end;
-+
-+	/* terminal type: no depth check */
-+
-+	if (duk_fb_is_full(fb)) {
-+		return;
-+	}
-+
-+	duk__print_shared_heaphdr_string(st, &h->hdr);
-+
-+	if (!h) {
-+		duk_fb_put_cstring(fb, "NULL");
-+		return;
-+	}
-+
-+	p = DUK_HSTRING_GET_DATA(h);
-+	p_end = p + DUK_HSTRING_GET_BYTELEN(h);
-+
-+	if (p_end > p && p[0] == DUK_ASC_UNDERSCORE) {
-+		/* if property key begins with underscore, encode it with
-+		 * forced quotes (e.g. "_Foo") to distinguish it from encoded
-+		 * internal properties (e.g. \xffBar -> _Bar).
-+		 */
-+		quotes = 1;
-+	}
-+
-+	if (quotes) {
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_DOUBLEQUOTE);
-+	}
-+	while (p < p_end) {
-+		duk_uint8_t ch = *p++;
-+
-+		/* two special escapes: '\' and '"', other printables as is */
-+		if (ch == '\\') {
-+			duk_fb_sprintf(fb, "\\\\");
-+		} else if (ch == '"') {
-+			duk_fb_sprintf(fb, "\\\"");
-+		} else if (ch >= 0x20 && ch <= 0x7e) {
-+			duk_fb_put_byte(fb, ch);
-+		} else if (ch == 0xff && !quotes) {
-+			/* encode \xffBar as _Bar if no quotes are applied, this is for
-+			 * readable internal keys.
-+			 */
-+			duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_UNDERSCORE);
-+		} else {
-+			duk_fb_sprintf(fb, "\\x%02lx", (unsigned long) ch);
-+		}
-+	}
-+	if (quotes) {
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_DOUBLEQUOTE);
-+	}
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	/* XXX: limit to quoted strings only, to save keys from being cluttered? */
-+	duk_fb_sprintf(fb, "/%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT(&h->hdr));
-+#endif
-+}
-+
-+#ifdef DUK__COMMA
-+#undef DUK__COMMA
-+#endif
-+#define DUK__COMMA()  do { \
-+		if (first) { \
-+			first = 0; \
-+		} else { \
-+			duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_COMMA); \
-+		} \
-+	} while (0)
-+
-+DUK_LOCAL void duk__print_hobject(duk__dprint_state *st, duk_hobject *h) {
-+	duk_fixedbuffer *fb = st->fb;
-+	duk_uint_fast32_t i;
-+	duk_tval *tv;
-+	duk_hstring *key;
-+	duk_bool_t first = 1;
-+	const char *brace1 = "{";
-+	const char *brace2 = "}";
-+	duk_bool_t pushed_loopstack = 0;
-+
-+	if (duk_fb_is_full(fb)) {
-+		return;
-+	}
-+
-+	duk__print_shared_heaphdr(st, &h->hdr);
-+
-+	if (h && DUK_HOBJECT_HAS_ARRAY_PART(h)) {
-+		brace1 = "[";
-+		brace2 = "]";
-+	}
-+
-+	if (!h) {
-+		duk_fb_put_cstring(fb, "NULL");
-+		goto finished;
-+	}
-+
-+	if (st->depth >= st->depth_limit) {
-+		if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
-+			duk_fb_sprintf(fb, "%sobject/compiledfunction %p%s", (const char *) brace1, (void *) h, (const char *) brace2);
-+		} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
-+			duk_fb_sprintf(fb, "%sobject/nativefunction %p%s", (const char *) brace1, (void *) h, (const char *) brace2);
-+		} else if (DUK_HOBJECT_IS_THREAD(h)) {
-+			duk_fb_sprintf(fb, "%sobject/thread %p%s", (const char *) brace1, (void *) h, (const char *) brace2);
-+		} else {
-+			duk_fb_sprintf(fb, "%sobject %p%s", (const char *) brace1, (void *) h, (const char *) brace2);  /* may be NULL */
-+		}
-+		return;
-+	}
-+
-+	for (i = 0; i < (duk_uint_fast32_t) st->loop_stack_index; i++) {
-+		if (st->loop_stack[i] == h) {
-+			duk_fb_sprintf(fb, "%sLOOP:%p%s", (const char *) brace1, (void *) h, (const char *) brace2);
-+			return;
-+		}
-+	}
-+
-+	/* after this, return paths should 'goto finished' for decrement */
-+	st->depth++;
-+
-+	if (st->loop_stack_index >= st->loop_stack_limit) {
-+		duk_fb_sprintf(fb, "%sOUT-OF-LOOP-STACK%s", (const char *) brace1, (const char *) brace2);
-+		goto finished;
-+	}
-+	st->loop_stack[st->loop_stack_index++] = h;
-+	pushed_loopstack = 1;
-+
-+	/*
-+	 *  Notation: double underscore used for internal properties which are not
-+	 *  stored in the property allocation (e.g. '__valstack').
-+	 */
-+
-+	duk_fb_put_cstring(fb, brace1);
-+
-+	if (DUK_HOBJECT_GET_PROPS(NULL, h)) {
-+		duk_uint32_t a_limit;
-+
-+		a_limit = DUK_HOBJECT_GET_ASIZE(h);
-+		if (st->internal) {
-+			/* dump all allocated entries, unused entries print as 'unused',
-+			 * note that these may extend beyond current 'length' and look
-+			 * a bit funny.
-+			 */
-+		} else {
-+			/* leave out trailing 'unused' elements */
-+			while (a_limit > 0) {
-+				tv = DUK_HOBJECT_A_GET_VALUE_PTR(NULL, h, a_limit - 1);
-+				if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
-+					break;
-+				}
-+				a_limit--;
-+			}
-+		}
-+
-+		for (i = 0; i < a_limit; i++) {
-+			tv = DUK_HOBJECT_A_GET_VALUE_PTR(NULL, h, i);
-+			DUK__COMMA();
-+			duk__print_tval(st, tv);
-+		}
-+		for (i = 0; i < DUK_HOBJECT_GET_ENEXT(h); i++) {
-+			key = DUK_HOBJECT_E_GET_KEY(NULL, h, i);
-+			if (!key) {
-+				continue;
-+			}
-+			if (!st->internal &&
-+			    DUK_HSTRING_GET_BYTELEN(key) > 0 &&
-+			    DUK_HSTRING_GET_DATA(key)[0] == 0xff) {
-+				/* XXX: use DUK_HSTRING_FLAG_INTERNAL? */
-+				continue;
-+			}
-+			DUK__COMMA();
-+			duk__print_hstring(st, key, 0);
-+			duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_COLON);
-+			if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(NULL, h, i)) {
-+				duk_fb_sprintf(fb, "[get:%p,set:%p]",
-+				               (void *) DUK_HOBJECT_E_GET_VALUE(NULL, h, i).a.get,
-+				               (void *) DUK_HOBJECT_E_GET_VALUE(NULL, h, i).a.set);
-+			} else {
-+				tv = &DUK_HOBJECT_E_GET_VALUE(NULL, h, i).v;
-+				duk__print_tval(st, tv);
-+			}
-+			if (st->heavy) {
-+				duk_fb_sprintf(fb, "<%02lx>", (unsigned long) DUK_HOBJECT_E_GET_FLAGS(NULL, h, i));
-+			}
-+		}
-+	}
-+	if (st->internal) {
-+		if (DUK_HOBJECT_HAS_EXTENSIBLE(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__extensible:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_CONSTRUCTABLE(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__constructable:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_BOUND(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__bound:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_COMPILEDFUNCTION(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__compiledfunction:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_NATIVEFUNCTION(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__nativefunction:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_THREAD(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__thread:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_ARRAY_PART(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__array_part:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_STRICT(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__strict:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_NEWENV(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__newenv:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_NAMEBINDING(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__namebinding:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_CREATEARGS(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__createargs:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_ENVRECCLOSED(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__envrecclosed:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__special_array:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__special_stringobj:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__special_arguments:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__special_dukfunc:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__special_bufferobj:true");
-+		} else {
-+			;
-+		}
-+		if (DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)) {
-+			DUK__COMMA(); duk_fb_sprintf(fb, "__special_proxyobj:true");
-+		} else {
-+			;
-+		}
-+	}
-+	if (st->internal && DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
-+		duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
-+		DUK__COMMA(); duk_fb_put_cstring(fb, "__data:");
-+		duk__print_hbuffer(st, (duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA(NULL, f));
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__nregs:%ld", (long) f->nregs);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__nargs:%ld", (long) f->nargs);
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__start_line:%ld", (long) f->start_line);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__end_line:%ld", (long) f->end_line);
-+#endif
-+		DUK__COMMA(); duk_fb_put_cstring(fb, "__data:");
-+		duk__print_hbuffer(st, (duk_hbuffer *) DUK_HCOMPILEDFUNCTION_GET_DATA(NULL, f));
-+	} else if (st->internal && DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
-+		duk_hnativefunction *f = (duk_hnativefunction *) h;
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__func:");
-+		duk_fb_put_funcptr(fb, (duk_uint8_t *) &f->func, sizeof(f->func));
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__nargs:%ld", (long) f->nargs);
-+	} else if (st->internal && DUK_HOBJECT_IS_THREAD(h)) {
-+		duk_hthread *t = (duk_hthread *) h;
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__strict:%ld", (long) t->strict);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__state:%ld", (long) t->state);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__unused1:%ld", (long) t->unused1);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__unused2:%ld", (long) t->unused2);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_max:%ld", (long) t->valstack_max);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__callstack_max:%ld", (long) t->callstack_max);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_max:%ld", (long) t->catchstack_max);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__valstack:%p", (void *) t->valstack);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_end:%p/%ld", (void *) t->valstack_end, (long) (t->valstack_end - t->valstack));
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_bottom:%p/%ld", (void *) t->valstack_bottom, (long) (t->valstack_bottom - t->valstack));
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__valstack_top:%p/%ld", (void *) t->valstack_top, (long) (t->valstack_top - t->valstack));
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack:%p", (void *) t->catchstack);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_size:%ld", (long) t->catchstack_size);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__catchstack_top:%ld", (long) t->catchstack_top);
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__resumer:"); duk__print_hobject(st, (duk_hobject *) t->resumer);
-+		/* XXX: print built-ins array? */
-+
-+	}
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	if (st->internal) {
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__refcount:%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h));
-+	}
-+#endif
-+	if (st->internal) {
-+		DUK__COMMA(); duk_fb_sprintf(fb, "__class:%ld", (long) DUK_HOBJECT_GET_CLASS_NUMBER(h));
-+	}
-+
-+	/* prototype should be last, for readability */
-+	if (st->follow_proto && DUK_HOBJECT_GET_PROTOTYPE(NULL, h)) {
-+		DUK__COMMA(); duk_fb_put_cstring(fb, "__prototype:"); duk__print_hobject(st, DUK_HOBJECT_GET_PROTOTYPE(NULL, h));
-+	}
-+
-+	duk_fb_put_cstring(fb, brace2);
-+
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	if (st->heavy && DUK_HOBJECT_GET_HSIZE(h) > 0) {
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LANGLE);
-+		for (i = 0; i < DUK_HOBJECT_GET_HSIZE(h); i++) {
-+			duk_uint_t h_idx = DUK_HOBJECT_H_GET_INDEX(NULL, h, i);
-+			if (i > 0) {
-+				duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_COMMA);
-+			}
-+			if (h_idx == DUK_HOBJECT_HASHIDX_UNUSED) {
-+				duk_fb_sprintf(fb, "u");
-+			} else if (h_idx == DUK_HOBJECT_HASHIDX_DELETED) {
-+				duk_fb_sprintf(fb, "d");
-+			} else {
-+				duk_fb_sprintf(fb, "%ld", (long) h_idx);
-+			}
-+		}
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RANGLE);
-+	}
-+#endif
-+
-+ finished:
-+	st->depth--;
-+	if (pushed_loopstack) {
-+		st->loop_stack_index--;
-+		st->loop_stack[st->loop_stack_index] = NULL;
-+	}
-+}
-+
-+#undef DUK__COMMA
-+
-+DUK_LOCAL void duk__print_hbuffer(duk__dprint_state *st, duk_hbuffer *h) {
-+	duk_fixedbuffer *fb = st->fb;
-+	duk_size_t i, n;
-+	duk_uint8_t *p;
-+
-+	if (duk_fb_is_full(fb)) {
-+		return;
-+	}
-+
-+	/* terminal type: no depth check */
-+
-+	if (!h) {
-+		duk_fb_put_cstring(fb, "NULL");
-+		return;
-+	}
-+
-+	if (DUK_HBUFFER_HAS_DYNAMIC(h)) {
-+		duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h;
-+		duk_fb_sprintf(fb, "buffer:dynamic:%p:%ld:%ld",
-+		               (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(NULL, g),
-+		               (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(g),
-+		               (long) DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(g));
-+	} else {
-+		duk_fb_sprintf(fb, "buffer:fixed:%ld", (long) DUK_HBUFFER_GET_SIZE(h));
-+	}
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk_fb_sprintf(fb, "/%lu", (unsigned long) DUK_HEAPHDR_GET_REFCOUNT(&h->hdr));
-+#endif
-+
-+	if (st->hexdump) {
-+		duk_fb_sprintf(fb, "=[");
-+		n = DUK_HBUFFER_GET_SIZE(h);
-+		p = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(NULL, h);
-+		for (i = 0; i < n; i++) {
-+			duk_fb_sprintf(fb, "%02lx", (unsigned long) p[i]);
-+		}
-+		duk_fb_sprintf(fb, "]");
-+	}
-+}
-+
-+DUK_LOCAL void duk__print_heaphdr(duk__dprint_state *st, duk_heaphdr *h) {
-+	duk_fixedbuffer *fb = st->fb;
-+
-+	if (duk_fb_is_full(fb)) {
-+		return;
-+	}
-+
-+	if (!h) {
-+		duk_fb_put_cstring(fb, "NULL");
-+		return;
-+	}
-+
-+	switch (DUK_HEAPHDR_GET_TYPE(h)) {
-+	case DUK_HTYPE_STRING:
-+		duk__print_hstring(st, (duk_hstring *) h, 1);
-+		break;
-+	case DUK_HTYPE_OBJECT:
-+		duk__print_hobject(st, (duk_hobject *) h);
-+		break;
-+	case DUK_HTYPE_BUFFER:
-+		duk__print_hbuffer(st, (duk_hbuffer *) h);
-+		break;
-+	default:
-+		duk_fb_sprintf(fb, "[unknown htype %ld]", (long) DUK_HEAPHDR_GET_TYPE(h));
-+		break;
-+	}
-+}
-+
-+DUK_LOCAL void duk__print_tval(duk__dprint_state *st, duk_tval *tv) {
-+	duk_fixedbuffer *fb = st->fb;
-+
-+	if (duk_fb_is_full(fb)) {
-+		return;
-+	}
-+
-+	/* depth check is done when printing an actual type */
-+
-+	if (st->heavy) {
-+		duk_fb_sprintf(fb, "(%p)", (void *) tv);
-+	}
-+
-+	if (!tv) {
-+		duk_fb_put_cstring(fb, "NULL");
-+		return;
-+	}
-+
-+	if (st->binary) {
-+		duk_size_t i;
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LBRACKET);
-+		for (i = 0; i < (duk_size_t) sizeof(*tv); i++) {
-+			duk_fb_sprintf(fb, "%02lx", (unsigned long) ((duk_uint8_t *)tv)[i]);
-+		}
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RBRACKET);
-+	}
-+
-+	if (st->heavy) {
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_LANGLE);
-+	}
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED: {
-+		if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
-+			duk_fb_put_cstring(fb, "unused");
-+		} else {
-+			duk_fb_put_cstring(fb, "undefined");
-+		}
-+		break;
-+	}
-+	case DUK_TAG_NULL: {
-+		duk_fb_put_cstring(fb, "null");
-+		break;
-+	}
-+	case DUK_TAG_BOOLEAN: {
-+		duk_fb_put_cstring(fb, DUK_TVAL_GET_BOOLEAN(tv) ? "true" : "false");
-+		break;
-+	}
-+	case DUK_TAG_STRING: {
-+		/* Note: string is a terminal heap object, so no depth check here */
-+		duk__print_hstring(st, DUK_TVAL_GET_STRING(tv), 1);
-+		break;
-+	}
-+	case DUK_TAG_OBJECT: {
-+		duk__print_hobject(st, DUK_TVAL_GET_OBJECT(tv));
-+		break;
-+	}
-+	case DUK_TAG_BUFFER: {
-+		duk__print_hbuffer(st, DUK_TVAL_GET_BUFFER(tv));
-+		break;
-+	}
-+	case DUK_TAG_POINTER: {
-+		duk_fb_sprintf(fb, "pointer:%p", (void *) DUK_TVAL_GET_POINTER(tv));
-+		break;
-+	}
-+	case DUK_TAG_LIGHTFUNC: {
-+		duk_c_function func;
-+		duk_small_uint_t lf_flags;
-+
-+		DUK_TVAL_GET_LIGHTFUNC(tv, func, lf_flags);
-+		duk_fb_sprintf(fb, "lightfunc:");
-+		duk_fb_put_funcptr(fb, (duk_uint8_t *) &func, sizeof(func));
-+		duk_fb_sprintf(fb, ":%04lx", (long) lf_flags);
-+		break;
-+	}
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default: {
-+		/* IEEE double is approximately 16 decimal digits; print a couple extra */
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		duk_fb_sprintf(fb, "%.18g", (double) DUK_TVAL_GET_NUMBER(tv));
-+		break;
-+	}
-+	}
-+	if (st->heavy) {
-+		duk_fb_put_byte(fb, (duk_uint8_t) DUK_ASC_RANGLE);
-+	}
-+}
-+
-+DUK_LOCAL void duk__print_instr(duk__dprint_state *st, duk_instr_t ins) {
-+	duk_fixedbuffer *fb = st->fb;
-+	duk_small_int_t op;
-+	const char *op_name;
-+	const char *extraop_name;
-+
-+	op = (duk_small_int_t) DUK_DEC_OP(ins);
-+	op_name = duk__bc_optab[op];
-+
-+	/* XXX: option to fix opcode length so it lines up nicely */
-+
-+	if (op == DUK_OP_EXTRA) {
-+		extraop_name = duk__bc_extraoptab[DUK_DEC_A(ins)];
-+
-+		duk_fb_sprintf(fb, "%s %ld, %ld",
-+		               (const char *) extraop_name, (long) DUK_DEC_B(ins), (long) DUK_DEC_C(ins));
-+	} else if (op == DUK_OP_JUMP) {
-+		duk_int_t diff1 = DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS;  /* from next pc */
-+		duk_int_t diff2 = diff1 + 1;                            /* from curr pc */
-+
-+		duk_fb_sprintf(fb, "%s %ld (to pc%c%ld)",
-+		               (const char *) op_name, (long) diff1,
-+		               (int) (diff2 >= 0 ? '+' : '-'),  /* char format: use int */
-+		               (long) (diff2 >= 0 ? diff2 : -diff2));
-+	} else {
-+		duk_fb_sprintf(fb, "%s %ld, %ld, %ld",
-+		               (const char *) op_name, (long) DUK_DEC_A(ins),
-+		               (long) DUK_DEC_B(ins), (long) DUK_DEC_C(ins));
-+	}
-+}
-+
-+DUK_LOCAL void duk__print_opcode(duk__dprint_state *st, duk_small_int_t opcode) {
-+	duk_fixedbuffer *fb = st->fb;
-+
-+	if (opcode < DUK_BC_OP_MIN || opcode > DUK_BC_OP_MAX) {
-+		duk_fb_sprintf(fb, "?(%ld)", (long) opcode);
-+	} else {
-+		duk_fb_sprintf(fb, "%s", (const char *) duk__bc_optab[opcode]);
-+	}
-+}
-+
-+DUK_INTERNAL duk_int_t duk_debug_vsnprintf(char *str, duk_size_t size, const char *format, va_list ap) {
-+	duk_fixedbuffer fb;
-+	const char *p = format;
-+	const char *p_end = p + DUK_STRLEN(format);
-+	duk_int_t retval;
-+
-+	DUK_MEMZERO(&fb, sizeof(fb));
-+	fb.buffer = (duk_uint8_t *) str;
-+	fb.length = size;
-+	fb.offset = 0;
-+	fb.truncated = 0;
-+
-+	while (p < p_end) {
-+		char ch = *p++;
-+		const char *p_begfmt = NULL;
-+		duk_bool_t got_exclamation = 0;
-+		duk_bool_t got_long = 0;  /* %lf, %ld etc */
-+		duk__dprint_state st;
-+
-+		if (ch != DUK_ASC_PERCENT) {
-+			duk_fb_put_byte(&fb, (duk_uint8_t) ch);
-+			continue;
-+		}
-+
-+		/*
-+		 *  Format tag parsing.  Since we don't understand all the
-+		 *  possible format tags allowed, we just scan for a terminating
-+		 *  specifier and keep track of relevant modifiers that we do
-+		 *  understand.  See man 3 printf.
-+		 */
-+
-+		DUK_MEMZERO(&st, sizeof(st));
-+		st.fb = &fb;
-+		st.depth = 0;
-+		st.depth_limit = 1;
-+		st.loop_stack_index = 0;
-+		st.loop_stack_limit = DUK__LOOP_STACK_DEPTH;
-+
-+		p_begfmt = p - 1;
-+		while (p < p_end) {
-+			ch = *p++;
-+
-+			if (ch == DUK_ASC_STAR) {
-+				/* unsupported: would consume multiple args */
-+				goto error;
-+			} else if (ch == DUK_ASC_PERCENT) {
-+				duk_fb_put_byte(&fb, (duk_uint8_t) DUK_ASC_PERCENT);
-+				break;
-+			} else if (ch == DUK_ASC_EXCLAMATION) {
-+				got_exclamation = 1;
-+			} else if (!got_exclamation && ch == DUK_ASC_LC_L) {
-+				got_long = 1;
-+			} else if (got_exclamation && ch == DUK_ASC_LC_D) {
-+				st.depth_limit = DUK__DEEP_DEPTH_LIMIT;
-+			} else if (got_exclamation && ch == DUK_ASC_LC_P) {
-+				st.follow_proto = 1;
-+			} else if (got_exclamation && ch == DUK_ASC_LC_I) {
-+				st.internal = 1;
-+			} else if (got_exclamation && ch == DUK_ASC_LC_X) {
-+				st.hexdump = 1;
-+			} else if (got_exclamation && ch == DUK_ASC_LC_H) {
-+				st.heavy = 1;
-+			} else if (got_exclamation && ch == DUK_ASC_ATSIGN) {
-+				st.pointer = 1;
-+			} else if (got_exclamation && ch == DUK_ASC_HASH) {
-+				st.binary = 1;
-+			} else if (got_exclamation && ch == DUK_ASC_UC_T) {
-+				duk_tval *t = va_arg(ap, duk_tval *);
-+				if (st.pointer && !st.heavy) {
-+					duk_fb_sprintf(&fb, "(%p)", (void *) t);
-+				}
-+				duk__print_tval(&st, t);
-+				break;
-+			} else if (got_exclamation && ch == DUK_ASC_UC_O) {
-+				duk_heaphdr *t = va_arg(ap, duk_heaphdr *);
-+				if (st.pointer && !st.heavy) {
-+					duk_fb_sprintf(&fb, "(%p)", (void *) t);
-+				}
-+				duk__print_heaphdr(&st, t);
-+				break;
-+			} else if (got_exclamation && ch == DUK_ASC_UC_I) {
-+				duk_instr_t t = va_arg(ap, duk_instr_t);
-+				duk__print_instr(&st, t);
-+				break;
-+			} else if (got_exclamation && ch == DUK_ASC_UC_C) {
-+				long t = va_arg(ap, long);
-+				duk__print_opcode(&st, (duk_small_int_t) t);
-+				break;
-+			} else if (!got_exclamation && strchr(DUK__ALLOWED_STANDARD_SPECIFIERS, (int) ch)) {
-+				char fmtbuf[DUK__MAX_FORMAT_TAG_LENGTH];
-+				duk_size_t fmtlen;
-+
-+				DUK_ASSERT(p >= p_begfmt);
-+				fmtlen = (duk_size_t) (p - p_begfmt);
-+				if (fmtlen >= sizeof(fmtbuf)) {
-+					/* format is too large, abort */
-+					goto error;
-+				}
-+				DUK_MEMZERO(fmtbuf, sizeof(fmtbuf));
-+				DUK_MEMCPY(fmtbuf, p_begfmt, fmtlen);
-+
-+				/* assume exactly 1 arg, which is why '*' is forbidden; arg size still
-+				 * depends on type though.
-+				 */
-+
-+				if (ch == DUK_ASC_LC_F || ch == DUK_ASC_LC_G || ch == DUK_ASC_LC_E) {
-+					/* %f and %lf both consume a 'long' */
-+					double arg = va_arg(ap, double);
-+					duk_fb_sprintf(&fb, fmtbuf, arg);
-+				} else if (ch == DUK_ASC_LC_D && got_long) {
-+					/* %ld */
-+					long arg = va_arg(ap, long);
-+					duk_fb_sprintf(&fb, fmtbuf, arg);
-+				} else if (ch == DUK_ASC_LC_D) {
-+					/* %d; only 16 bits are guaranteed */
-+					int arg = va_arg(ap, int);
-+					duk_fb_sprintf(&fb, fmtbuf, arg);
-+				} else if (ch == DUK_ASC_LC_U && got_long) {
-+					/* %lu */
-+					unsigned long arg = va_arg(ap, unsigned long);
-+					duk_fb_sprintf(&fb, fmtbuf, arg);
-+				} else if (ch == DUK_ASC_LC_U) {
-+					/* %u; only 16 bits are guaranteed */
-+					unsigned int arg = va_arg(ap, unsigned int);
-+					duk_fb_sprintf(&fb, fmtbuf, arg);
-+				} else if (ch == DUK_ASC_LC_X && got_long) {
-+					/* %lx */
-+					unsigned long arg = va_arg(ap, unsigned long);
-+					duk_fb_sprintf(&fb, fmtbuf, arg);
-+				} else if (ch == DUK_ASC_LC_X) {
-+					/* %x; only 16 bits are guaranteed */
-+					unsigned int arg = va_arg(ap, unsigned int);
-+					duk_fb_sprintf(&fb, fmtbuf, arg);
-+				} else if (ch == DUK_ASC_LC_S) {
-+					/* %s */
-+					const char *arg = va_arg(ap, const char *);
-+					if (arg == NULL) {
-+						/* '%s' and NULL is not portable, so special case
-+						 * it for debug printing.
-+						 */
-+						duk_fb_sprintf(&fb, "NULL");
-+					} else {
-+						duk_fb_sprintf(&fb, fmtbuf, arg);
-+					}
-+				} else if (ch == DUK_ASC_LC_P) {
-+					/* %p */
-+					void *arg = va_arg(ap, void *);
-+					if (arg == NULL) {
-+						/* '%p' and NULL is portable, but special case it
-+						 * anyway to get a standard NULL marker in logs.
-+						 */
-+						duk_fb_sprintf(&fb, "NULL");
-+					} else {
-+						duk_fb_sprintf(&fb, fmtbuf, arg);
-+					}
-+				} else if (ch == DUK_ASC_LC_C) {
-+					/* '%c', passed concretely as int */
-+					int arg = va_arg(ap, int);
-+					duk_fb_sprintf(&fb, fmtbuf, arg);
-+				} else {
-+					/* Should not happen. */
-+					duk_fb_sprintf(&fb, "INVALID-FORMAT(%s)", (const char *) fmtbuf);
-+				}
-+				break;
-+			} else {
-+				/* ignore */
-+			}
-+		}
-+	}
-+	goto done;
-+
-+ error:
-+	duk_fb_put_cstring(&fb, "FMTERR");
-+	/* fall through */
-+
-+ done:
-+	retval = (duk_int_t) fb.offset;
-+	duk_fb_put_byte(&fb, (duk_uint8_t) 0);
-+
-+	/* return total chars written excluding terminator */
-+	return retval;
-+}
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL duk_int_t duk_debug_snprintf(char *str, duk_size_t size, const char *format, ...) {
-+	duk_int_t retval;
-+	va_list ap;
-+	va_start(ap, format);
-+	retval = duk_debug_vsnprintf(str, size, format, ap);
-+	va_end(ap);
-+	return retval;
-+}
-+#endif
-+
-+/* Formatting function pointers is tricky: there is no standard pointer for
-+ * function pointers and the size of a function pointer may depend on the
-+ * specific pointer type.  This helper formats a function pointer based on
-+ * its memory layout to get something useful on most platforms.
-+ */
-+DUK_INTERNAL void duk_debug_format_funcptr(char *buf, duk_size_t buf_size, duk_uint8_t *fptr, duk_size_t fptr_size) {
-+	duk_size_t i;
-+	duk_uint8_t *p = (duk_uint8_t *) buf;
-+	duk_uint8_t *p_end = (duk_uint8_t *) (buf + buf_size - 1);
-+
-+	DUK_MEMZERO(buf, buf_size);
-+
-+	for (i = 0; i < fptr_size; i++) {
-+		duk_int_t left = (duk_int_t) (p_end - p);
-+		duk_uint8_t ch;
-+		if (left <= 0) {
-+			break;
-+		}
-+
-+		/* Quite approximate but should be useful for little and big endian. */
-+#ifdef DUK_USE_INTEGER_BE
-+		ch = fptr[i];
-+#else
-+		ch = fptr[fptr_size - 1 - i];
-+#endif
-+		p += DUK_SNPRINTF((char *) p, left, "%02lx", (unsigned long) ch);
-+	}
-+}
-+
-+#endif  /* DUK_USE_DEBUG */
-+#line 1 "duk_debugger.c"
-+/*
-+ *  Duktape debugger
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+
-+/*
-+ *  Helper structs
-+ */
-+
-+typedef union {
-+	void *p;
-+	duk_uint_t b[1];
-+	/* Use b[] to access the size of the union, which is strictly not
-+	 * correct.  Can't use fixed size unless there's feature detection
-+	 * for pointer byte size.
-+	 */
-+} duk__ptr_union;
-+
-+/*
-+ *  Detach handling
-+ */
-+
-+#define DUK__SET_CONN_BROKEN(thr) do { \
-+		/* For now shared handler is fine. */ \
-+		duk_debug_do_detach((thr)->heap); \
-+	} while (0)
-+
-+DUK_INTERNAL void duk_debug_do_detach(duk_heap *heap) {
-+	/* Can be called muliple times with no harm. */
-+
-+	heap->dbg_read_cb = NULL;
-+	heap->dbg_write_cb = NULL;
-+	heap->dbg_peek_cb = NULL;
-+	heap->dbg_read_flush_cb = NULL;
-+	heap->dbg_write_flush_cb = NULL;
-+	if (heap->dbg_detached_cb) {
-+		heap->dbg_detached_cb(heap->dbg_udata);
-+	}
-+	heap->dbg_detached_cb = NULL;
-+	heap->dbg_udata = NULL;
-+	heap->dbg_processing = 0;
-+	heap->dbg_paused = 0;
-+	heap->dbg_state_dirty = 0;
-+	heap->dbg_step_type = 0;
-+	heap->dbg_step_thread = NULL;
-+	heap->dbg_step_csindex = 0;
-+	heap->dbg_step_startline = 0;
-+
-+	/* Ensure there are no stale active breakpoint pointers.
-+	 * Breakpoint list is currently kept - we could empty it
-+	 * here but we'd need to handle refcounts correctly, and
-+	 * we'd need a 'thr' reference for that.
-+	 *
-+	 * XXX: clear breakpoint on either attach or detach?
-+	 */
-+	heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL;
-+}
-+
-+/*
-+ *  Debug connection peek and flush primitives
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_debug_read_peek(duk_hthread *thr) {
-+	duk_heap *heap;
-+
-+	DUK_ASSERT(thr != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	if (heap->dbg_read_cb == NULL) {
-+		DUK_D(DUK_DPRINT("attempt to peek in detached state, return zero (= no data)"));
-+		return 0;
-+	}
-+	if (heap->dbg_peek_cb == NULL) {
-+		DUK_DD(DUK_DDPRINT("no peek callback, return zero (= no data)"));
-+		return 0;
-+	}
-+
-+	return (duk_bool_t) (heap->dbg_peek_cb(heap->dbg_udata) > 0);
-+}
-+
-+DUK_INTERNAL void duk_debug_read_flush(duk_hthread *thr) {
-+	duk_heap *heap;
-+
-+	DUK_ASSERT(thr != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	if (heap->dbg_read_cb == NULL) {
-+		DUK_D(DUK_DPRINT("attempt to read flush in detached state, ignore"));
-+		return;
-+	}
-+	if (heap->dbg_read_flush_cb == NULL) {
-+		DUK_DD(DUK_DDPRINT("no read flush callback, ignore"));
-+		return;
-+	}
-+
-+	heap->dbg_read_flush_cb(heap->dbg_udata);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_flush(duk_hthread *thr) {
-+	duk_heap *heap;
-+
-+	DUK_ASSERT(thr != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	if (heap->dbg_read_cb == NULL) {
-+		DUK_D(DUK_DPRINT("attempt to write flush in detached state, ignore"));
-+		return;
-+	}
-+	if (heap->dbg_write_flush_cb == NULL) {
-+		DUK_DD(DUK_DDPRINT("no write flush callback, ignore"));
-+		return;
-+	}
-+
-+	heap->dbg_write_flush_cb(heap->dbg_udata);
-+}
-+
-+/*
-+ *  Debug connection skip primitives
-+ */
-+
-+/* Skip fully. */
-+DUK_INTERNAL void duk_debug_skip_bytes(duk_hthread *thr, duk_size_t length) {
-+	duk_uint8_t dummy[64];
-+	duk_size_t now;
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	while (length > 0) {
-+		now = (length > sizeof(dummy) ? sizeof(dummy) : length);
-+		duk_debug_read_bytes(thr, dummy, now);
-+		length -= now;
-+	}
-+}
-+
-+DUK_INTERNAL void duk_debug_skip_byte(duk_hthread *thr) {
-+	DUK_ASSERT(thr != NULL);
-+
-+	(void) duk_debug_read_byte(thr);
-+}
-+
-+/*
-+ *  Debug connection read primitives
-+ */
-+
-+/* Read fully. */
-+DUK_INTERNAL void duk_debug_read_bytes(duk_hthread *thr, duk_uint8_t *data, duk_size_t length) {
-+	duk_heap *heap;
-+	duk_uint8_t *p;
-+	duk_size_t left;
-+	duk_size_t got;
-+
-+	DUK_ASSERT(thr != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	if (heap->dbg_read_cb == NULL) {
-+		DUK_D(DUK_DPRINT("attempt to read %ld bytes in detached state, return zero data", (long) length));
-+		goto fail;
-+	}
-+
-+	p = data;
-+	for (;;) {
-+		left = (duk_size_t) ((data + length) - p);
-+		if (left == 0) {
-+			break;
-+		}
-+		DUK_ASSERT(heap->dbg_read_cb != NULL);
-+		DUK_ASSERT(left >= 1);
-+#if defined(DUK_USE_DEBUGGER_TRANSPORT_TORTURE)
-+		left = 1;
-+#endif
-+		got = heap->dbg_read_cb(heap->dbg_udata, (char *) p, left);
-+		if (got == 0 || got > left) {
-+			DUK_D(DUK_DPRINT("connection error during read, return zero data"));
-+			DUK__SET_CONN_BROKEN(thr);
-+			goto fail;
-+		}
-+		p += got;
-+	}
-+	return;
-+
-+ fail:
-+	DUK_MEMZERO((void *) data, (size_t) length);
-+}
-+
-+DUK_INTERNAL duk_uint8_t duk_debug_read_byte(duk_hthread *thr) {
-+	duk_heap *heap;
-+	duk_size_t got;
-+	duk_uint8_t x;
-+
-+	DUK_ASSERT(thr != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	if (heap->dbg_read_cb == NULL) {
-+		DUK_D(DUK_DPRINT("attempt to read 1 bytes in detached state, return zero data"));
-+		return 0;
-+	}
-+
-+	x = 0;  /* just in case callback is broken and won't write 'x' */
-+	DUK_ASSERT(heap->dbg_read_cb != NULL);
-+	got = heap->dbg_read_cb(heap->dbg_udata, (char *) (&x), 1);
-+	if (got != 1) {
-+		DUK_D(DUK_DPRINT("connection error during read, return zero data"));
-+		DUK__SET_CONN_BROKEN(thr);
-+		return 0;
-+	}
-+
-+	return x;
-+}
-+
-+DUK_LOCAL duk_uint32_t duk__debug_read_uint32_raw(duk_hthread *thr) {
-+	duk_uint8_t buf[4];
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	duk_debug_read_bytes(thr, buf, 4);
-+	return ((duk_uint32_t) buf[0] << 24) |
-+	       ((duk_uint32_t) buf[1] << 16) |
-+	       ((duk_uint32_t) buf[2] << 8) |
-+	       (duk_uint32_t) buf[3];
-+}
-+
-+DUK_LOCAL duk_uint32_t duk__debug_read_int32_raw(duk_hthread *thr) {
-+	return (duk_int32_t) duk__debug_read_uint32_raw(thr);
-+}
-+
-+DUK_LOCAL duk_uint16_t duk__debug_read_uint16_raw(duk_hthread *thr) {
-+	duk_uint8_t buf[2];
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	duk_debug_read_bytes(thr, buf, 2);
-+	return ((duk_uint16_t) buf[0] << 8) |
-+	       (duk_uint16_t) buf[1];
-+}
-+
-+DUK_INTERNAL duk_int32_t duk_debug_read_int(duk_hthread *thr) {
-+	duk_small_uint_t x;
-+	duk_small_uint_t t;
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	x = duk_debug_read_byte(thr);
-+	if (x >= 0xc0) {
-+		t = duk_debug_read_byte(thr);
-+		return (duk_int32_t) (((x - 0xc0) << 8) + t);
-+	} else if (x >= 0x80) {
-+		return (duk_int32_t) (x - 0x80);
-+	} else if (x == 0x10) {
-+		return (duk_int32_t) duk__debug_read_uint32_raw(thr);
-+	}
-+
-+	DUK_D(DUK_DPRINT("debug connection error: failed to decode int"));
-+	DUK__SET_CONN_BROKEN(thr);
-+	return 0;
-+}
-+
-+DUK_LOCAL duk_hstring *duk__debug_read_hstring_raw(duk_hthread *thr, duk_uint32_t len) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_uint8_t buf[31];
-+	duk_uint8_t *p;
-+
-+	if (len <= sizeof(buf)) {
-+		duk_debug_read_bytes(thr, buf, (duk_size_t) len);
-+		duk_push_lstring(ctx, (const char *) buf, (duk_size_t) len);
-+	} else {
-+		p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len);
-+		DUK_ASSERT(p != NULL);
-+		duk_debug_read_bytes(thr, p, (duk_size_t) len);
-+		duk_to_string(ctx, -1);
-+	}
-+
-+	return duk_require_hstring(ctx, -1);
-+}
-+
-+DUK_INTERNAL duk_hstring *duk_debug_read_hstring(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_small_uint_t x;
-+	duk_uint32_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	x = duk_debug_read_byte(thr);
-+	if (x >= 0x60 && x <= 0x7f) {
-+		/* For short strings, use a fixed temp buffer. */
-+		len = (duk_uint32_t) (x - 0x60);
-+	} else if (x == 0x12) {
-+		len = (duk_uint32_t) duk__debug_read_uint16_raw(thr);
-+	} else if (x == 0x11) {
-+		len = (duk_uint32_t) duk__debug_read_uint32_raw(thr);
-+	} else {
-+		goto fail;
-+	}
-+
-+	return duk__debug_read_hstring_raw(thr, len);
-+
-+ fail:
-+	DUK_D(DUK_DPRINT("debug connection error: failed to decode int"));
-+	DUK__SET_CONN_BROKEN(thr);
-+	duk_push_hstring_stridx(thr, DUK_STRIDX_EMPTY_STRING);  /* always push some string */
-+	return duk_require_hstring(ctx, -1);
-+}
-+
-+DUK_LOCAL duk_hbuffer *duk__debug_read_hbuffer_raw(duk_hthread *thr, duk_uint32_t len) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_uint8_t *p;
-+
-+	p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, (duk_size_t) len);
-+	DUK_ASSERT(p != NULL);
-+	duk_debug_read_bytes(thr, p, (duk_size_t) len);
-+
-+	return duk_require_hbuffer(ctx, -1);
-+}
-+
-+DUK_LOCAL const void *duk__debug_read_pointer_raw(duk_hthread *thr) {
-+	duk_small_uint_t x;
-+	volatile duk__ptr_union pu;
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	x = duk_debug_read_byte(thr);
-+	if (x != sizeof(pu)) {
-+		goto fail;
-+	}
-+	duk_debug_read_bytes(thr, (duk_uint8_t *) &pu.p, sizeof(pu));
-+#if defined(DUK_USE_INTEGER_LE)
-+	duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu));
-+#endif
-+	return (const void *) pu.p;
-+
-+ fail:
-+	DUK_D(DUK_DPRINT("debug connection error: failed to decode pointer"));
-+	DUK__SET_CONN_BROKEN(thr);
-+	return (const void *) NULL;
-+}
-+
-+DUK_LOCAL duk_double_t duk__debug_read_double_raw(duk_hthread *thr) {
-+	duk_double_union du;
-+
-+	DUK_ASSERT(sizeof(du.uc) == 8);
-+	duk_debug_read_bytes(thr, (duk_uint8_t *) du.uc, sizeof(du.uc));
-+	DUK_DBLUNION_BSWAP(&du);
-+	return du.d;
-+}
-+
-+DUK_INTERNAL void duk_debug_read_tval(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_uint8_t x;
-+	duk_uint_t t;
-+	duk_uint32_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	x = duk_debug_read_byte(thr);
-+
-+	if (x >= 0xc0) {
-+		t = (duk_uint_t) (x - 0xc0);
-+		t = (t << 8) + duk_debug_read_byte(thr);
-+		duk_push_uint(ctx, (duk_uint_t) t);
-+		return;
-+	}
-+	if (x >= 0x80) {
-+		duk_push_uint(ctx, (duk_uint_t) (x - 0x80));
-+		return;
-+	}
-+	if (x >= 0x60) {
-+		len = (duk_uint32_t) (x - 0x60);
-+		duk__debug_read_hstring_raw(thr, len);
-+		return;
-+	}
-+
-+	switch (x) {
-+	case 0x10: {
-+		duk_int32_t i = duk__debug_read_int32_raw(thr);
-+		duk_push_i32(ctx, i);
-+		break;
-+	}
-+	case 0x11:
-+		len = duk__debug_read_uint32_raw(thr);
-+		duk__debug_read_hstring_raw(thr, len);
-+		break;
-+	case 0x12:
-+		len = duk__debug_read_uint16_raw(thr);
-+		duk__debug_read_hstring_raw(thr, len);
-+		break;
-+	case 0x13:
-+		len = duk__debug_read_uint32_raw(thr);
-+		duk__debug_read_hbuffer_raw(thr, len);
-+		break;
-+	case 0x14:
-+		len = duk__debug_read_uint16_raw(thr);
-+		duk__debug_read_hbuffer_raw(thr, len);
-+		break;
-+	case 0x15:
-+		duk_push_unused(ctx);
-+		break;
-+	case 0x16:
-+		duk_push_undefined(ctx);
-+		break;
-+	case 0x17:
-+		duk_push_null(ctx);
-+		break;
-+	case 0x18:
-+		duk_push_true(ctx);
-+		break;
-+	case 0x19:
-+		duk_push_false(ctx);
-+		break;
-+	case 0x1a: {
-+		duk_double_t d;
-+		d = duk__debug_read_double_raw(thr);
-+		duk_push_number(ctx, d);
-+		break;
-+	}
-+	case 0x1b:
-+		/* XXX: not needed for now, so not implemented */
-+		DUK_D(DUK_DPRINT("reading object values unimplemented"));
-+		goto fail;
-+	case 0x1c: {
-+		const void *ptr;
-+		ptr = duk__debug_read_pointer_raw(thr);
-+		duk_push_pointer(thr, (void *) ptr);
-+		break;
-+	}
-+	case 0x1d:
-+		/* XXX: not needed for now, so not implemented */
-+		DUK_D(DUK_DPRINT("reading lightfunc values unimplemented"));
-+		goto fail;
-+	case 0x1e: {
-+		duk_heaphdr *h;
-+		h = (duk_heaphdr *) duk__debug_read_pointer_raw(thr);
-+		duk_push_heapptr(thr, (void *) h);
-+		break;
-+	}
-+	default:
-+		goto fail;
-+	}
-+
-+	return;
-+
-+ fail:
-+	DUK_D(DUK_DPRINT("debug connection error: failed to decode tval"));
-+	DUK__SET_CONN_BROKEN(thr);
-+}
-+
-+/*
-+ *  Debug connection write primitives
-+ */
-+
-+/* Write fully. */
-+DUK_INTERNAL void duk_debug_write_bytes(duk_hthread *thr, const duk_uint8_t *data, duk_size_t length) {
-+	duk_heap *heap;
-+	const duk_uint8_t *p;
-+	duk_size_t left;
-+	duk_size_t got;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(length == 0 || data != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	if (heap->dbg_write_cb == NULL) {
-+		DUK_D(DUK_DPRINT("attempt to write %ld bytes in detached state, ignore", (long) length));
-+		return;
-+	}
-+	if (length == 0) {
-+		/* Avoid doing an actual write callback with length == 0,
-+		 * because that's reserved for a write flush.
-+		 */
-+		return;
-+	}
-+	DUK_ASSERT(data != NULL);
-+
-+	p = data;
-+	for (;;) {
-+		left = (duk_size_t) ((data + length) - p);
-+		if (left == 0) {
-+			break;
-+		}
-+		DUK_ASSERT(heap->dbg_write_cb != NULL);
-+		DUK_ASSERT(left >= 1);
-+#if defined(DUK_USE_DEBUGGER_TRANSPORT_TORTURE)
-+		left = 1;
-+#endif
-+		got = heap->dbg_write_cb(heap->dbg_udata, (const char *) p, left);
-+		if (got == 0 || got > left) {
-+			DUK_D(DUK_DPRINT("connection error during write"));
-+			DUK__SET_CONN_BROKEN(thr);
-+			return;
-+		}
-+		p += got;
-+	}
-+}
-+
-+DUK_INTERNAL void duk_debug_write_byte(duk_hthread *thr, duk_uint8_t x) {
-+	duk_heap *heap;
-+	duk_size_t got;
-+
-+	DUK_ASSERT(thr != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	if (heap->dbg_write_cb == NULL) {
-+		DUK_D(DUK_DPRINT("attempt to write 1 bytes in detached state, ignore"));
-+		return;
-+	}
-+
-+	DUK_ASSERT(heap->dbg_write_cb != NULL);
-+	got = heap->dbg_write_cb(heap->dbg_udata, (const char *) (&x), 1);
-+	if (got != 1) {
-+		DUK_D(DUK_DPRINT("connection error during write"));
-+		DUK__SET_CONN_BROKEN(thr);
-+	}
-+}
-+
-+DUK_INTERNAL void duk_debug_write_unused(duk_hthread *thr) {
-+	duk_debug_write_byte(thr, 0x15);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_undefined(duk_hthread *thr) {
-+	duk_debug_write_byte(thr, 0x16);
-+}
-+
-+/* Write signed 32-bit integer. */
-+DUK_INTERNAL void duk_debug_write_int(duk_hthread *thr, duk_int32_t x) {
-+	duk_uint8_t buf[5];
-+	duk_size_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	if (x >= 0 && x <= 0x3fL) {
-+		buf[0] = (duk_uint8_t) (0x80 + x);
-+		len = 1;
-+	} else if (x >= 0 && x <= 0x3fffL) {
-+		buf[0] = (duk_uint8_t) (0xc0 + (x >> 8));
-+		buf[1] = (duk_uint8_t) (x & 0xff);
-+		len = 2;
-+	} else {
-+		/* Signed integers always map to 4 bytes now. */
-+		buf[0] = (duk_uint8_t) 0x10;
-+		buf[1] = (duk_uint8_t) ((x >> 24) & 0xff);
-+		buf[2] = (duk_uint8_t) ((x >> 16) & 0xff);
-+		buf[3] = (duk_uint8_t) ((x >> 8) & 0xff);
-+		buf[4] = (duk_uint8_t) (x & 0xff);
-+		len = 5;
-+	}
-+	duk_debug_write_bytes(thr, buf, len);
-+}
-+
-+/* Write unsigned 32-bit integer. */
-+DUK_INTERNAL void duk_debug_write_uint(duk_hthread *thr, duk_uint32_t x) {
-+	/* XXX: there's currently no need to support full 32-bit unsigned
-+	 * integer range in practice.  If that becomes necessary, add a new
-+	 * dvalue type or encode as an IEEE double.
-+	 */
-+	duk_debug_write_int(thr, (duk_int32_t) x);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_strbuf(duk_hthread *thr, const char *data, duk_size_t length, duk_uint8_t marker_base) {
-+	duk_uint8_t buf[5];
-+	duk_size_t buflen;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(length == 0 || data != NULL);
-+
-+	if (length <= 0x1fUL && marker_base == 0x11) {
-+		/* For strings, special form for short lengths. */
-+		buf[0] = (duk_uint8_t) (0x60 + length);
-+		buflen = 1;
-+	} else if (length <= 0xffffUL) {
-+		buf[0] = (duk_uint8_t) (marker_base + 1);
-+		buf[1] = (duk_uint8_t) (length >> 8);
-+		buf[2] = (duk_uint8_t) (length & 0xff);
-+		buflen = 3;
-+	} else {
-+		buf[0] = (duk_uint8_t) marker_base;
-+		buf[1] = (duk_uint8_t) (length >> 24);
-+		buf[2] = (duk_uint8_t) ((length >> 16) & 0xff);
-+		buf[3] = (duk_uint8_t) ((length >> 8) & 0xff);
-+		buf[4] = (duk_uint8_t) (length & 0xff);
-+		buflen = 5;
-+	}
-+
-+	duk_debug_write_bytes(thr, (const duk_uint8_t *) buf, buflen);
-+	duk_debug_write_bytes(thr, (const duk_uint8_t *) data, length);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_string(duk_hthread *thr, const char *data, duk_size_t length) {
-+	duk_debug_write_strbuf(thr, data, length, 0x11);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_cstring(duk_hthread *thr, const char *data) {
-+	DUK_ASSERT(thr != NULL);
-+
-+	duk_debug_write_string(thr,
-+	                       data,
-+	                       data ? DUK_STRLEN(data) : 0);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_hstring(duk_hthread *thr, duk_hstring *h) {
-+	DUK_ASSERT(thr != NULL);
-+
-+	/* XXX: differentiate null pointer from empty string? */
-+	duk_debug_write_string(thr,
-+	                       (h != NULL ? (const char *) DUK_HSTRING_GET_DATA(h) : NULL),
-+	                       (h != NULL ? (duk_size_t) DUK_HSTRING_GET_BYTELEN(h) : 0));
-+}
-+
-+DUK_INTERNAL void duk_debug_write_buffer(duk_hthread *thr, const char *data, duk_size_t length) {
-+	duk_debug_write_strbuf(thr, data, length, 0x13);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_hbuffer(duk_hthread *thr, duk_hbuffer *h) {
-+	DUK_ASSERT(thr != NULL);
-+
-+	duk_debug_write_buffer(thr,
-+	                       (h != NULL ? (const char *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h) : NULL),
-+	                       (h != NULL ? (duk_size_t) DUK_HBUFFER_GET_SIZE(h) : 0));
-+}
-+
-+DUK_LOCAL void duk__debug_write_pointer_raw(duk_hthread *thr, const void *ptr, duk_uint8_t ibyte) {
-+	duk_uint8_t buf[2];
-+	volatile duk__ptr_union pu;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(sizeof(ptr) >= 1 && sizeof(ptr) <= 16);
-+	/* ptr may be NULL */
-+
-+	buf[0] = ibyte;
-+	buf[1] = sizeof(pu);
-+	duk_debug_write_bytes(thr, buf, 2);
-+	pu.p = (void *) ptr;
-+#if defined(DUK_USE_INTEGER_LE)
-+	duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu));
-+#endif
-+	duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu));
-+}
-+
-+DUK_INTERNAL void duk_debug_write_pointer(duk_hthread *thr, const void *ptr) {
-+	duk__debug_write_pointer_raw(thr, ptr, 0x1c);
-+}
-+
-+#if defined(DUK_USE_DEBUGGER_DUMPHEAP)
-+DUK_INTERNAL void duk_debug_write_heapptr(duk_hthread *thr, duk_heaphdr *h) {
-+	duk__debug_write_pointer_raw(thr, (const void *) h, 0x1e);
-+}
-+#endif  /* DUK_USE_DEBUGGER_DUMPHEAP */
-+
-+DUK_INTERNAL void duk_debug_write_hobject(duk_hthread *thr, duk_hobject *obj) {
-+	duk_uint8_t buf[3];
-+	volatile duk__ptr_union pu;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(sizeof(obj) >= 1 && sizeof(obj) <= 16);
-+	DUK_ASSERT(obj != NULL);
-+
-+	buf[0] = 0x1b;
-+	buf[1] = (duk_uint8_t) DUK_HOBJECT_GET_CLASS_NUMBER(obj);
-+	buf[2] = sizeof(pu);
-+	duk_debug_write_bytes(thr, buf, 3);
-+	pu.p = (void *) obj;
-+#if defined(DUK_USE_INTEGER_LE)
-+	duk_byteswap_bytes((duk_uint8_t *) pu.b, sizeof(pu));
-+#endif
-+	duk_debug_write_bytes(thr, (const duk_uint8_t *) &pu.p, (duk_size_t) sizeof(pu));
-+}
-+
-+DUK_INTERNAL void duk_debug_write_tval(duk_hthread *thr, duk_tval *tv) {
-+	duk_c_function lf_func;
-+	duk_small_uint_t lf_flags;
-+	duk_uint8_t buf[4];
-+	duk_double_union du;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(tv != NULL);
-+
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED:
-+		duk_debug_write_byte(thr,
-+		                     DUK_TVAL_IS_UNDEFINED_UNUSED(tv) ? 0x15 : 0x16);
-+		break;
-+	case DUK_TAG_NULL:
-+		duk_debug_write_byte(thr, 0x17);
-+		break;
-+	case DUK_TAG_BOOLEAN:
-+		DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv) == 0 ||
-+		           DUK_TVAL_GET_BOOLEAN(tv) == 1);
-+		duk_debug_write_byte(thr, DUK_TVAL_GET_BOOLEAN(tv) ? 0x18 : 0x19);
-+		break;
-+	case DUK_TAG_POINTER:
-+		duk_debug_write_pointer(thr, (const void *) DUK_TVAL_GET_POINTER(tv));
-+		break;
-+	case DUK_TAG_LIGHTFUNC:
-+		DUK_TVAL_GET_LIGHTFUNC(tv, lf_func, lf_flags);
-+		buf[0] = 0x1d;
-+		buf[1] = (duk_uint8_t) (lf_flags >> 8);
-+		buf[2] = (duk_uint8_t) (lf_flags & 0xff);
-+		buf[3] = sizeof(lf_func);
-+		duk_debug_write_bytes(thr, buf, 4);
-+		duk_debug_write_bytes(thr, (const duk_uint8_t *) &lf_func, sizeof(lf_func));
-+		break;
-+	case DUK_TAG_STRING:
-+		duk_debug_write_hstring(thr, DUK_TVAL_GET_STRING(tv));
-+		break;
-+	case DUK_TAG_OBJECT:
-+		duk_debug_write_hobject(thr, DUK_TVAL_GET_OBJECT(tv));
-+		break;
-+	case DUK_TAG_BUFFER:
-+		duk_debug_write_hbuffer(thr, DUK_TVAL_GET_BUFFER(tv));
-+		break;
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default:
-+		/* Numbers are normalized to big (network) endian. */
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		du.d = DUK_TVAL_GET_NUMBER(tv);
-+		DUK_DBLUNION_BSWAP(&du);
-+
-+		duk_debug_write_byte(thr, 0x1a);
-+		duk_debug_write_bytes(thr, (const duk_uint8_t *) du.uc, sizeof(du.uc));
-+	}
-+}
-+
-+#if defined(DUK_USE_DEBUGGER_DUMPHEAP)
-+/* Variant for writing duk_tvals so that any heap allocated values are
-+ * written out as tagged heap pointers.
-+ */
-+DUK_LOCAL void duk__debug_write_tval_heapptr(duk_hthread *thr, duk_tval *tv) {
-+	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
-+		duk_debug_write_heapptr(thr, h);
-+	} else {
-+		duk_debug_write_tval(thr, tv);
-+	}
-+}
-+#endif  /* DUK_USE_DEBUGGER_DUMPHEAP */
-+
-+/*
-+ *  Debug connection message write helpers
-+ */
-+
-+#if 0  /* unused */
-+DUK_INTERNAL void duk_debug_write_request(duk_hthread *thr, duk_small_uint_t command) {
-+	duk_debug_write_byte(thr, DUK_DBG_MARKER_REQUEST);
-+	duk_debug_write_int(thr, command);
-+}
-+#endif
-+
-+DUK_INTERNAL void duk_debug_write_reply(duk_hthread *thr) {
-+	duk_debug_write_byte(thr, DUK_DBG_MARKER_REPLY);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_error_eom(duk_hthread *thr, duk_small_uint_t err_code, const char *msg) {
-+	/* Allow NULL 'msg' */
-+	duk_debug_write_byte(thr, DUK_DBG_MARKER_ERROR);
-+	duk_debug_write_int(thr, (duk_int32_t) err_code);
-+	duk_debug_write_cstring(thr, msg);
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_notify(duk_hthread *thr, duk_small_uint_t command) {
-+	duk_debug_write_byte(thr, DUK_DBG_MARKER_NOTIFY);
-+	duk_debug_write_int(thr, command);
-+}
-+
-+DUK_INTERNAL void duk_debug_write_eom(duk_hthread *thr) {
-+	duk_debug_write_byte(thr, DUK_DBG_MARKER_EOM);
-+
-+	/* As an initial implementation, write flush after every EOM (and the
-+	 * version identifier).  A better implementation would flush only when
-+	 * Duktape is finished processing messages so that a flush only happens
-+	 * after all outbound messages are finished on that occasion.
-+	 */
-+	duk_debug_write_flush(thr);
-+}
-+
-+/*
-+ *  Status message and helpers
-+ */
-+
-+DUK_INTERNAL duk_uint_fast32_t duk_debug_curr_line(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_activation *act;
-+	duk_uint_fast32_t line;
-+	duk_uint_fast32_t pc;
-+
-+	if (thr->callstack_top == 0) {
-+		return 0;
-+	}
-+	act = thr->callstack + thr->callstack_top - 1;
-+
-+	/* act->pc indicates the next instruction about to be executed.  This
-+	 * is usually correct, but for the 'debugger' statement it will be the
-+	 * instruction after that.
-+	 */
-+
-+	pc = (duk_uint_fast32_t) act->pc;
-+
-+	/* XXX: this should be optimized to be a raw query and avoid valstack
-+	 * operations if possible.
-+	 */
-+	duk_push_hobject(ctx, act->func);
-+	line = duk_hobject_pc2line_query(ctx, -1, pc);
-+	duk_pop(ctx);
-+	return line;
-+}
-+
-+DUK_INTERNAL void duk_debug_send_status(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_activation *act;
-+
-+	duk_debug_write_notify(thr, DUK_DBG_CMD_STATUS);
-+	duk_debug_write_int(thr, thr->heap->dbg_paused);
-+
-+	DUK_ASSERT_DISABLE(thr->callstack_top >= 0);  /* unsigned */
-+	if (thr->callstack_top == 0) {
-+		duk_debug_write_undefined(thr);
-+		duk_debug_write_undefined(thr);
-+		duk_debug_write_int(thr, 0);
-+		duk_debug_write_int(thr, 0);
-+	} else {
-+		act = thr->callstack + thr->callstack_top - 1;
-+		duk_push_hobject(ctx, act->func);
-+		duk_get_prop_string(ctx, -1, "fileName");
-+		duk_safe_to_string(ctx, -1);
-+		duk_debug_write_hstring(thr, duk_require_hstring(ctx, -1));
-+		duk_get_prop_string(ctx, -2, "name");
-+		duk_safe_to_string(ctx, -1);
-+		duk_debug_write_hstring(thr, duk_require_hstring(ctx, -1));
-+		duk_pop_3(ctx);
-+		duk_debug_write_uint(thr, (duk_uint32_t) duk_debug_curr_line(thr));
-+		duk_debug_write_uint(thr, (duk_uint32_t) act->pc);
-+	}
-+
-+	duk_debug_write_eom(thr);
-+}
-+
-+/*
-+ *  Debug message processing
-+ */
-+
-+/* Skip dvalue. */
-+DUK_LOCAL duk_bool_t duk__debug_skip_dvalue(duk_hthread *thr) {
-+	duk_uint8_t x;
-+	duk_uint32_t len;
-+
-+	x = duk_debug_read_byte(thr);
-+
-+	if (x >= 0xc0) {
-+		duk_debug_skip_byte(thr);
-+		return 0;
-+	}
-+	if (x >= 0x80) {
-+		return 0;
-+	}
-+	if (x >= 0x60) {
-+		duk_debug_skip_bytes(thr, x - 0x60);
-+		return 0;
-+	}
-+	switch(x) {
-+	case 0x00:
-+		return 1;  /* Return 1: got EOM */
-+	case 0x01:
-+	case 0x02:
-+	case 0x03:
-+	case 0x04:
-+		break;
-+	case 0x10:
-+		(void) duk__debug_read_uint32_raw(thr);
-+		break;
-+	case 0x11:
-+	case 0x13:
-+		len = duk__debug_read_uint32_raw(thr);
-+		duk_debug_skip_bytes(thr, len);
-+		break;
-+	case 0x12:
-+	case 0x14:
-+		len = duk__debug_read_uint16_raw(thr);
-+		duk_debug_skip_bytes(thr, len);
-+		break;
-+	case 0x15:
-+	case 0x16:
-+	case 0x17:
-+	case 0x18:
-+	case 0x19:
-+		break;
-+	case 0x1a:
-+		duk_debug_skip_bytes(thr, 8);
-+		break;
-+	case 0x1b:
-+		duk_debug_skip_byte(thr);
-+		len = duk_debug_read_byte(thr);
-+		duk_debug_skip_bytes(thr, len);
-+		break;
-+	case 0x1c:
-+		len = duk_debug_read_byte(thr);
-+		duk_debug_skip_bytes(thr, len);
-+		break;
-+	case 0x1d:
-+		duk_debug_skip_bytes(thr, 2);
-+		len = duk_debug_read_byte(thr);
-+		duk_debug_skip_bytes(thr, len);
-+		break;
-+	default:
-+		goto fail;
-+	}
-+
-+	return 0;
-+
-+ fail:
-+	DUK__SET_CONN_BROKEN(thr);
-+	return 1;  /* Pretend like we got EOM */
-+}
-+
-+/* Skip dvalues to EOM. */
-+DUK_LOCAL void duk__debug_skip_to_eom(duk_hthread *thr) {
-+	for (;;) {
-+		if (duk__debug_skip_dvalue(thr)) {
-+			break;
-+		}
-+	}
-+}
-+
-+/*
-+ *  Process incoming debug requests
-+ */
-+
-+DUK_LOCAL void duk__debug_handle_basic_info(duk_hthread *thr, duk_heap *heap) {
-+	DUK_UNREF(heap);
-+	DUK_D(DUK_DPRINT("debug command version"));
-+
-+	duk_debug_write_reply(thr);
-+	duk_debug_write_int(thr, DUK_VERSION);
-+	duk_debug_write_cstring(thr, DUK_GIT_DESCRIBE);
-+	duk_debug_write_cstring(thr, DUK_USE_TARGET_INFO);
-+#if defined(DUK_USE_DOUBLE_LE)
-+	duk_debug_write_int(thr, 1);
-+#elif defined(DUK_USE_DOUBLE_ME)
-+	duk_debug_write_int(thr, 2);
-+#elif defined(DUK_USE_DOUBLE_BE)
-+	duk_debug_write_int(thr, 3);
-+#else
-+	duk_debug_write_int(thr, 0);
-+#endif
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_trigger_status(duk_hthread *thr, duk_heap *heap) {
-+	DUK_UNREF(heap);
-+	DUK_D(DUK_DPRINT("debug command triggerstatus"));
-+
-+	duk_debug_write_reply(thr);
-+	duk_debug_write_eom(thr);
-+	heap->dbg_state_dirty = 1;
-+}
-+
-+DUK_LOCAL void duk__debug_handle_pause(duk_hthread *thr, duk_heap *heap) {
-+	DUK_D(DUK_DPRINT("debug command pause"));
-+
-+	DUK_HEAP_SET_PAUSED(heap);
-+	duk_debug_write_reply(thr);
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_resume(duk_hthread *thr, duk_heap *heap) {
-+	DUK_D(DUK_DPRINT("debug command resume"));
-+
-+	DUK_HEAP_CLEAR_PAUSED(heap);
-+	duk_debug_write_reply(thr);
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_step(duk_hthread *thr, duk_heap *heap, duk_int32_t cmd) {
-+	duk_small_uint_t step_type;
-+	duk_uint_fast32_t line;
-+
-+	if (cmd == DUK_DBG_CMD_STEPINTO) {
-+		step_type = DUK_STEP_TYPE_INTO;
-+	} else if (cmd == DUK_DBG_CMD_STEPOVER) {
-+		step_type = DUK_STEP_TYPE_OVER;
-+	} else {
-+		DUK_ASSERT(cmd == DUK_DBG_CMD_STEPOUT);
-+		step_type = DUK_STEP_TYPE_OUT;
-+	}
-+
-+	DUK_D(DUK_DPRINT("debug command stepinto/stepover/stepout: %d", (int) cmd));
-+	line = duk_debug_curr_line(thr);
-+	if (line > 0) {
-+		heap->dbg_paused = 0;
-+		heap->dbg_step_type = step_type;
-+		heap->dbg_step_thread = thr;
-+		heap->dbg_step_csindex = thr->callstack_top - 1;
-+		heap->dbg_step_startline = line;
-+		heap->dbg_state_dirty = 1;
-+	} else {
-+		DUK_D(DUK_DPRINT("cannot determine current line, stepinto/stepover/stepout ignored"));
-+	}
-+	duk_debug_write_reply(thr);
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_list_break(duk_hthread *thr, duk_heap *heap) {
-+	duk_small_int_t i;
-+
-+	DUK_D(DUK_DPRINT("debug command listbreak"));
-+	duk_debug_write_reply(thr);
-+	for (i = 0; i < (duk_small_int_t) heap->dbg_breakpoint_count; i++) {
-+		duk_debug_write_hstring(thr, heap->dbg_breakpoints[i].filename);
-+		duk_debug_write_uint(thr, (duk_uint32_t) heap->dbg_breakpoints[i].line);
-+	}
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_add_break(duk_hthread *thr, duk_heap *heap) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *filename;
-+	duk_uint32_t linenumber;
-+	duk_small_int_t idx;
-+
-+	DUK_UNREF(heap);
-+
-+	filename = duk_debug_read_hstring(thr);
-+	linenumber = (duk_uint32_t) duk_debug_read_int(thr);
-+	DUK_D(DUK_DPRINT("debug command addbreak: %!O:%ld", (duk_hobject *) filename, (long) linenumber));
-+	idx = duk_debug_add_breakpoint(thr, filename, linenumber);
-+	if (idx >= 0) {
-+		duk_debug_write_reply(thr);
-+		duk_debug_write_int(thr, (duk_int32_t) idx);
-+		duk_debug_write_eom(thr);
-+	} else {
-+		duk_debug_write_error_eom(thr, DUK_DBG_ERR_TOOMANY, "no space for breakpoint");
-+	}
-+	duk_pop(ctx);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_del_break(duk_hthread *thr, duk_heap *heap) {
-+	duk_small_uint_t idx;
-+
-+	DUK_UNREF(heap);
-+
-+	DUK_D(DUK_DPRINT("debug command delbreak"));
-+	idx = (duk_small_uint_t) duk_debug_read_int(thr);
-+	if (duk_debug_remove_breakpoint(thr, idx)) {
-+		duk_debug_write_reply(thr);
-+		duk_debug_write_eom(thr);
-+	} else {
-+		duk_debug_write_error_eom(thr, DUK_DBG_ERR_NOTFOUND, "invalid breakpoint index");
-+	}
-+}
-+
-+DUK_LOCAL void duk__debug_handle_get_var(duk_hthread *thr, duk_heap *heap) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *str;
-+	duk_bool_t rc;
-+
-+	DUK_UNREF(heap);
-+	DUK_D(DUK_DPRINT("debug command getvar"));
-+
-+	str = duk_debug_read_hstring(thr);  /* push to stack */
-+	DUK_ASSERT(str != NULL);
-+
-+	if (thr->callstack_top > 0) {
-+		rc = duk_js_getvar_activation(thr,
-+		                              thr->callstack + thr->callstack_top - 1,
-+		                              str,
-+		                              0);
-+	} else {
-+		/* No activation, no variable access.  Could also pretend
-+		 * we're in the global program context and read stuff off
-+		 * the global object.
-+		 */
-+		DUK_D(DUK_DPRINT("callstack empty, no activation -> ignore getvar"));
-+		rc = 0;
-+	}
-+
-+	duk_debug_write_reply(thr);
-+	if (rc) {
-+		duk_debug_write_int(thr, 1);
-+		duk_debug_write_tval(thr, duk_require_tval(ctx, -2));
-+		duk_pop_2(ctx);
-+	} else {
-+		duk_debug_write_int(thr, 0);
-+		duk_debug_write_unused(thr);
-+	}
-+	duk_pop(ctx);
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_put_var(duk_hthread *thr, duk_heap *heap) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *str;
-+	duk_tval *tv;
-+
-+	DUK_UNREF(heap);
-+	DUK_D(DUK_DPRINT("debug command putvar"));
-+
-+	str = duk_debug_read_hstring(thr);  /* push to stack */
-+	DUK_ASSERT(str != NULL);
-+	duk_debug_read_tval(thr);           /* push to stack */
-+	tv = duk_require_tval(ctx, -1);
-+
-+	if (thr->callstack_top > 0) {
-+		duk_js_putvar_activation(thr,
-+		                         thr->callstack + thr->callstack_top - 1,
-+		                         str,
-+		                         tv,
-+		                         0);
-+	} else {
-+		DUK_D(DUK_DPRINT("callstack empty, no activation -> ignore putvar"));
-+	}
-+	duk_pop_2(ctx);
-+
-+	/* XXX: Current putvar implementation doesn't have a success flag,
-+	 * add one and send to debug client?
-+	 */
-+	duk_debug_write_reply(thr);
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_get_call_stack(duk_hthread *thr, duk_heap *heap) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hthread *curr_thr = thr;
-+	duk_activation *curr_act;
-+	duk_uint_fast32_t line;
-+	duk_size_t i;
-+
-+	DUK_UNREF(heap);
-+
-+	duk_debug_write_reply(thr);
-+	while (curr_thr != NULL) {
-+		i = curr_thr->callstack_top;
-+		while (i > 0) {
-+			i--;
-+			curr_act = curr_thr->callstack + i;
-+
-+			/* XXX: optimize to use direct reads,
-+			 * i.e. avoid value stack operations.
-+			 */
-+			duk_push_tval(ctx, &curr_act->tv_func);
-+			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
-+			duk_safe_to_string(ctx, -1);
-+			duk_debug_write_hstring(thr, duk_get_hstring(ctx, -1));
-+			duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);
-+			duk_safe_to_string(ctx, -1);
-+			duk_debug_write_hstring(thr, duk_get_hstring(ctx, -1));
-+			line = duk_hobject_pc2line_query(ctx, -3, curr_act->pc);
-+			duk_debug_write_uint(thr, (duk_uint32_t) line);
-+			duk_debug_write_uint(thr, (duk_uint32_t) curr_act->pc);
-+			duk_pop_3(ctx);
-+		}
-+		curr_thr = curr_thr->resumer;
-+	}
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_get_locals(duk_hthread *thr, duk_heap *heap) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_activation *curr_act;
-+	duk_hstring *varname;
-+
-+	DUK_UNREF(heap);
-+
-+	duk_debug_write_reply(thr);
-+	if (thr->callstack_top == 0) {
-+		goto callstack_empty;
-+	}
-+	curr_act = thr->callstack + thr->callstack_top - 1;
-+
-+	/* XXX: several nice-to-have improvements here:
-+	 *   - Use direct reads avoiding value stack operations
-+	 *   - Avoid triggering getters, indicate getter values to debug client
-+	 *   - If side effects are possible, add error catching
-+	 */
-+
-+	duk_push_tval(ctx, &curr_act->tv_func);
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VARMAP);
-+	if (duk_is_object(ctx, -1)) {
-+		duk_enum(ctx, -1, 0 /*enum_flags*/);
-+		while (duk_next(ctx, -1 /*enum_index*/, 0 /*get_value*/)) {
-+			varname = duk_get_hstring(ctx, -1);
-+			DUK_ASSERT(varname != NULL);
-+
-+			duk_js_getvar_activation(thr, curr_act, varname, 0 /*throw_flag*/);
-+			/* [ ... func varmap enum key value this ] */
-+			duk_debug_write_hstring(thr, duk_get_hstring(ctx, -3));
-+			duk_debug_write_tval(thr, duk_get_tval(ctx, -2));
-+			duk_pop_3(ctx);  /* -> [ ... func varmap enum ] */
-+		}
-+		duk_pop(ctx);
-+	} else {
-+		DUK_D(DUK_DPRINT("varmap is not an object in GetLocals, ignore"));
-+	}
-+	duk_pop_2(ctx);
-+
-+ callstack_empty:
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_eval(duk_hthread *thr, duk_heap *heap) {
-+	duk_context *ctx = (duk_context *) thr;
-+
-+	duk_small_uint_t call_flags;
-+	duk_int_t call_ret;
-+	duk_small_int_t eval_err;
-+#if defined(DUK_USE_ASSERTIONS)
-+	duk_idx_t entry_top;
-+#endif
-+
-+	DUK_UNREF(heap);
-+
-+	DUK_D(DUK_DPRINT("debug command eval"));
-+
-+	/* The eval code must be executed within the current (topmost)
-+	 * activation.  For now, use global object eval() function, with
-+	 * the eval considered a 'direct call to eval'.
-+	 */
-+
-+#if defined(DUK_USE_ASSERTIONS)
-+	entry_top = duk_get_top(ctx);
-+#endif
-+
-+	duk_push_c_function(ctx, duk_bi_global_object_eval, 1 /*nargs*/);
-+	duk_push_undefined(ctx);  /* 'this' binding shouldn't matter here */
-+	(void) duk_debug_read_hstring(thr);
-+
-+	/* [ ... eval "eval" eval_input ] */
-+
-+	call_flags = DUK_CALL_FLAG_PROTECTED;
-+	if (thr->callstack_top >= 1) {
-+		duk_activation *act;
-+		duk_hobject *fun;
-+
-+		act = thr->callstack + thr->callstack_top - 1;
-+		fun = DUK_ACT_GET_FUNC(act);
-+		if (fun && DUK_HOBJECT_IS_COMPILEDFUNCTION(fun)) {
-+			/* Direct eval requires that there's a current
-+			 * activation and it is an Ecmascript function.
-+			 * When Eval is executed from e.g. cooperate API
-+			 * call we'll need to an indirect eval instead.
-+			 */
-+			call_flags |= DUK_CALL_FLAG_DIRECT_EVAL;
-+		}
-+	}
-+
-+	call_ret = duk_handle_call(thr, 1 /*num_stack_args*/, call_flags);
-+
-+	if (call_ret == DUK_EXEC_SUCCESS) {
-+		eval_err = 0;
-+		/* Use result value as is. */
-+	} else {
-+		/* For errors a string coerced result is most informative
-+		 * right now, as the debug client doesn't have the capability
-+		 * to traverse the error object.
-+		 */
-+		eval_err = 1;
-+		duk_safe_to_string(ctx, -1);
-+	}
-+
-+	/* [ ... result ] */
-+
-+	duk_debug_write_reply(thr);
-+	duk_debug_write_int(thr, (duk_int32_t) eval_err);
-+	duk_debug_write_tval(thr, duk_require_tval(ctx, -1));
-+	duk_debug_write_eom(thr);
-+	duk_pop(ctx);
-+
-+	DUK_ASSERT(duk_get_top(ctx) == entry_top);
-+}
-+
-+DUK_LOCAL void duk__debug_handle_detach(duk_hthread *thr, duk_heap *heap) {
-+	DUK_UNREF(heap);
-+	DUK_D(DUK_DPRINT("debug command detach"));
-+
-+	duk_debug_write_reply(thr);
-+	duk_debug_write_eom(thr);
-+
-+	DUK_D(DUK_DPRINT("debug connection detached, mark broken"));
-+	DUK__SET_CONN_BROKEN(thr);
-+}
-+
-+#if defined(DUK_USE_DEBUGGER_DUMPHEAP)
-+DUK_LOCAL void duk__debug_dump_heaphdr(duk_hthread *thr, duk_heap *heap, duk_heaphdr *hdr) {
-+	DUK_UNREF(heap);
-+
-+	duk_debug_write_heapptr(thr, hdr);
-+	duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_TYPE(hdr));
-+	duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_FLAGS_RAW(hdr));
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+	duk_debug_write_uint(thr, (duk_uint32_t) DUK_HEAPHDR_GET_REFCOUNT(hdr));
-+#else
-+	duk_debug_write_int(thr, (duk_int32_t) -1);
-+#endif
-+
-+	switch (DUK_HEAPHDR_GET_TYPE(hdr)) {
-+	case DUK_HTYPE_STRING: {
-+		duk_hstring *h = (duk_hstring *) hdr;
-+
-+		duk_debug_write_uint(thr, (duk_int32_t) DUK_HSTRING_GET_BYTELEN(h));
-+		duk_debug_write_uint(thr, (duk_int32_t) DUK_HSTRING_GET_CHARLEN(h));
-+		duk_debug_write_uint(thr, (duk_int32_t) DUK_HSTRING_GET_HASH(h));
-+		duk_debug_write_hstring(thr, h);
-+		break;
-+	}
-+	case DUK_HTYPE_OBJECT: {
-+		duk_hobject *h = (duk_hobject *) hdr;
-+		duk_hstring *k;
-+		duk_uint_fast32_t i;
-+
-+		duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_CLASS_NUMBER(h));
-+		duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(heap, h));
-+		duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ESIZE(h));
-+		duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ENEXT(h));
-+		duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_ASIZE(h));
-+		duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_GET_HSIZE(h));
-+
-+		for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
-+			duk_debug_write_uint(thr, (duk_uint32_t) DUK_HOBJECT_E_GET_FLAGS(heap, h, i));
-+			k = DUK_HOBJECT_E_GET_KEY(heap, h, i);
-+			duk_debug_write_heapptr(thr, (duk_heaphdr *) k);
-+			if (k == NULL) {
-+				duk_debug_write_int(thr, 0);  /* isAccessor */
-+				duk_debug_write_unused(thr);
-+				continue;
-+			}
-+			if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) {
-+				duk_debug_write_int(thr, 1);  /* isAccessor */
-+				duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get);
-+				duk_debug_write_heapptr(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set);
-+			} else {
-+				duk_debug_write_int(thr, 0);  /* isAccessor */
-+
-+				duk__debug_write_tval_heapptr(thr, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v);
-+			}
-+		}
-+
-+		for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
-+			/* Note: array dump will include elements beyond
-+			 * 'length'.
-+			 */
-+			duk__debug_write_tval_heapptr(thr, DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i));
-+		}
-+		break;
-+	}
-+	case DUK_HTYPE_BUFFER: {
-+		duk_hbuffer *h = (duk_hbuffer *) hdr;
-+
-+		duk_debug_write_uint(thr, (duk_uint32_t) DUK_HBUFFER_GET_SIZE(h));
-+		if (DUK_HBUFFER_HAS_DYNAMIC(h)) {
-+			duk_debug_write_uint(thr, (duk_uint32_t) DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE((duk_hbuffer_dynamic *) h));
-+		} else {
-+			duk_debug_write_uint(thr, (duk_uint32_t) DUK_HBUFFER_GET_SIZE(h));
-+		}
-+		duk_debug_write_buffer(thr, (const char *) DUK_HBUFFER_GET_DATA_PTR(heap, h), (duk_size_t) DUK_HBUFFER_GET_SIZE(h));
-+		break;
-+	}
-+	default: {
-+		DUK_D(DUK_DPRINT("invalid htype: %d", (int) DUK_HEAPHDR_GET_TYPE(hdr)));
-+	}
-+	}
-+}
-+
-+DUK_LOCAL void duk__debug_dump_heap_allocated(duk_hthread *thr, duk_heap *heap) {
-+	duk_heaphdr *hdr;
-+
-+	hdr = heap->heap_allocated;
-+	while (hdr != NULL) {
-+		duk__debug_dump_heaphdr(thr, heap, hdr);
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+}
-+
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+DUK_LOCAL void duk__debug_dump_strtab_chain(duk_hthread *thr, duk_heap *heap) {
-+	duk_uint_fast32_t i, j;
-+	duk_strtab_entry *e;
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t *lst;
-+#else
-+	duk_hstring **lst;
-+#endif
-+	duk_hstring *h;
-+
-+	for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
-+		e = heap->strtable + i;
-+		if (e->listlen > 0) {
-+#if defined(DUK_USE_HEAPPTR16)
-+			lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-+#else
-+			lst = e->u.strlist;
-+#endif
-+			DUK_ASSERT(lst != NULL);
-+
-+			for (j = 0; j < e->listlen; j++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+				h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[j]);
-+#else
-+				h = lst[j];
-+#endif
-+				if (h != NULL) {
-+					duk__debug_dump_heaphdr(thr, heap, (duk_heaphdr *) h);
-+				}
-+			}
-+		} else {
-+#if defined(DUK_USE_HEAPPTR16)
-+			h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16);
-+#else
-+			h = e->u.str;
-+#endif
-+			if (h != NULL) {
-+				duk__debug_dump_heaphdr(thr, heap, (duk_heaphdr *) h);
-+			}
-+		}
-+	}
-+}
-+#endif  /* DUK_USE_STRTAB_CHAIN */
-+
-+#if defined(DUK_USE_STRTAB_PROBE)
-+DUK_LOCAL void duk__debug_dump_strtab_probe(duk_hthread *thr, duk_heap *heap) {
-+	duk_uint32_t i;
-+	duk_hstring *h;
-+
-+	for (i = 0; i < heap->st_size; i++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+		h = DUK_USE_HEAPPTR_DEC16(heap->strtable16[i]);
-+#else
-+		h = heap->strtable[i];
-+#endif
-+		if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
-+			continue;
-+		}
-+
-+		duk__debug_dump_heaphdr(thr, heap, (duk_heaphdr *) h);
-+	}
-+}
-+#endif  /* DUK_USE_STRTAB_PROBE */
-+
-+DUK_LOCAL void duk__debug_handle_dump_heap(duk_hthread *thr, duk_heap *heap) {
-+	DUK_D(DUK_DPRINT("debug command dumpheap"));
-+
-+	duk_debug_write_reply(thr);
-+	duk__debug_dump_heap_allocated(thr, heap);
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	duk__debug_dump_strtab_chain(thr, heap);
-+#endif
-+#if defined(DUK_USE_STRTAB_PROBE)
-+	duk__debug_dump_strtab_probe(thr, heap);
-+#endif
-+	duk_debug_write_eom(thr);
-+}
-+#endif  /* DUK_USE_DEBUGGER_DUMPHEAP */
-+
-+DUK_LOCAL void duk__debug_handle_get_bytecode(duk_hthread *thr, duk_heap *heap) {
-+	duk_activation *act;
-+	duk_hcompiledfunction *fun;
-+	duk_size_t i, n;
-+	duk_tval *tv;
-+	duk_hobject **fn;
-+
-+	DUK_UNREF(heap);
-+
-+	DUK_D(DUK_DPRINT("debug command getbytecode"));
-+
-+	duk_debug_write_reply(thr);
-+	if (thr->callstack_top == 0) {
-+		fun = NULL;
-+	} else {
-+		act = thr->callstack + thr->callstack_top - 1;
-+		fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act);
-+		if (!DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun)) {
-+			fun = NULL;
-+		}
-+	}
-+	DUK_ASSERT(fun == NULL || DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun));
-+
-+	if (fun) {
-+		n = DUK_HCOMPILEDFUNCTION_GET_CONSTS_COUNT(heap, fun);
-+		duk_debug_write_int(thr, (int) n);
-+		tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, fun);
-+		for (i = 0; i < n; i++) {
-+			duk_debug_write_tval(thr, tv);
-+			tv++;
-+		}
-+
-+		n = DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(heap, fun);
-+		duk_debug_write_int(thr, (int) n);
-+		fn = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, fun);
-+		for (i = 0; i < n; i++) {
-+			duk_debug_write_hobject(thr, *fn);
-+			fn++;
-+		}
-+
-+		duk_debug_write_string(thr,
-+		                       (const char *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(heap, fun),
-+		                       (duk_size_t) DUK_HCOMPILEDFUNCTION_GET_CODE_SIZE(heap, fun));
-+	} else {
-+		duk_debug_write_int(thr, 0);
-+		duk_debug_write_int(thr, 0);
-+		duk_debug_write_cstring(thr, "");
-+	}
-+	duk_debug_write_eom(thr);
-+}
-+
-+DUK_LOCAL void duk__debug_process_message(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_heap *heap;
-+	duk_uint8_t x;
-+	duk_int32_t cmd;
-+
-+	DUK_ASSERT(thr != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+	DUK_UNREF(ctx);
-+
-+	x = duk_debug_read_byte(thr);
-+	switch (x) {
-+	case DUK_DBG_MARKER_REQUEST: {
-+		cmd = duk_debug_read_int(thr);
-+		switch (cmd) {
-+		case DUK_DBG_CMD_BASICINFO: {
-+			duk__debug_handle_basic_info(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_TRIGGERSTATUS: {
-+			duk__debug_handle_trigger_status(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_PAUSE: {
-+			duk__debug_handle_pause(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_RESUME: {
-+			duk__debug_handle_resume(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_STEPINTO:
-+		case DUK_DBG_CMD_STEPOVER:
-+		case DUK_DBG_CMD_STEPOUT: {
-+			duk__debug_handle_step(thr, heap, cmd);
-+			break;
-+		}
-+		case DUK_DBG_CMD_LISTBREAK: {
-+			duk__debug_handle_list_break(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_ADDBREAK: {
-+			duk__debug_handle_add_break(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_DELBREAK: {
-+			duk__debug_handle_del_break(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_GETVAR: {
-+			duk__debug_handle_get_var(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_PUTVAR: {
-+			duk__debug_handle_put_var(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_GETCALLSTACK: {
-+			duk__debug_handle_get_call_stack(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_GETLOCALS: {
-+			duk__debug_handle_get_locals(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_EVAL: {
-+			duk__debug_handle_eval(thr, heap);
-+			break;
-+		}
-+		case DUK_DBG_CMD_DETACH: {
-+			duk__debug_handle_detach(thr, heap);
-+			break;
-+		}
-+#if defined(DUK_USE_DEBUGGER_DUMPHEAP)
-+		case DUK_DBG_CMD_DUMPHEAP: {
-+			duk__debug_handle_dump_heap(thr, heap);
-+			break;
-+		}
-+#endif  /* DUK_USE_DEBUGGER_DUMPHEAP */
-+		case DUK_DBG_CMD_GETBYTECODE: {
-+			duk__debug_handle_get_bytecode(thr, heap);
-+			break;
-+		}
-+		default: {
-+			DUK_D(DUK_DPRINT("debug command unsupported: %d", (int) cmd));
-+			duk_debug_write_error_eom(thr, DUK_DBG_ERR_UNSUPPORTED, "unsupported command");
-+		}
-+		}  /* switch cmd */
-+		break;
-+	}
-+	case DUK_DBG_MARKER_REPLY: {
-+		DUK_D(DUK_DPRINT("debug reply, skipping"));
-+		break;
-+	}
-+	case DUK_DBG_MARKER_ERROR: {
-+		DUK_D(DUK_DPRINT("debug error, skipping"));
-+		break;
-+	}
-+	case DUK_DBG_MARKER_NOTIFY: {
-+		DUK_D(DUK_DPRINT("debug notify, skipping"));
-+		break;
-+	}
-+	default: {
-+		DUK_D(DUK_DPRINT("invalid initial byte, drop connection: %d", (int) x));
-+		goto fail;
-+	}
-+	}  /* switch initial byte */
-+
-+	duk__debug_skip_to_eom(thr);
-+	return;
-+
-+ fail:
-+	DUK__SET_CONN_BROKEN(thr);
-+	return;
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_debug_process_messages(duk_hthread *thr, duk_bool_t no_block) {
-+	duk_context *ctx = (duk_context *) thr;
-+#if defined(DUK_USE_ASSERTIONS)
-+	duk_idx_t entry_top;
-+#endif
-+	duk_bool_t retval = 0;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_UNREF(ctx);
-+#if defined(DUK_USE_ASSERTIONS)
-+	entry_top = duk_get_top(ctx);
-+#endif
-+
-+	DUK_DD(DUK_DDPRINT("top at entry: %ld", (long) duk_get_top(ctx)));
-+
-+	for (;;) {
-+		/* Process messages until we're no longer paused or we peek
-+		 * and see there's nothing to read right now.
-+		 */
-+		DUK_DD(DUK_DDPRINT("top at loop top: %ld", (long) duk_get_top(ctx)));
-+
-+		if (thr->heap->dbg_read_cb == NULL) {
-+			DUK_D(DUK_DPRINT("debug connection broken, stop processing messages"));
-+			break;
-+		} else if (!thr->heap->dbg_paused || no_block) {
-+			if (!duk_debug_read_peek(thr)) {
-+				DUK_D(DUK_DPRINT("processing debug message, peek indicated no data, stop processing"));
-+				break;
-+			}
-+			DUK_D(DUK_DPRINT("processing debug message, peek indicated there is data, handle it"));
-+		} else {
-+			DUK_D(DUK_DPRINT("paused, process debug message, blocking if necessary"));
-+		}
-+
-+		duk__debug_process_message(thr);
-+		if (thr->heap->dbg_state_dirty) {
-+			/* Executed something that may have affected status,
-+			 * resend.
-+			 */
-+			duk_debug_send_status(thr);
-+			thr->heap->dbg_state_dirty = 0;
-+		}
-+		retval = 1;  /* processed one or more messages */
-+	}
-+
-+	/* As an initial implementation, read flush after exiting the message
-+	 * loop.
-+	 */
-+	duk_debug_read_flush(thr);
-+
-+	DUK_DD(DUK_DDPRINT("top at exit: %ld", (long) duk_get_top(ctx)));
-+
-+#if defined(DUK_USE_ASSERTIONS)
-+	/* Easy to get wrong, so assert for it. */
-+	DUK_ASSERT(entry_top == duk_get_top(ctx));
-+#endif
-+
-+	return retval;
-+}
-+
-+/*
-+ *  Breakpoint management
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_debug_add_breakpoint(duk_hthread *thr, duk_hstring *filename, duk_uint32_t line) {
-+	duk_heap *heap;
-+	duk_breakpoint *b;
-+
-+	/* Caller must trigger recomputation of active breakpoint list.  To
-+	 * ensure stale values are not used if that doesn't happen, clear the
-+	 * active breakpoint list here.
-+	 */
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(filename != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	if (heap->dbg_breakpoint_count >= DUK_HEAP_MAX_BREAKPOINTS) {
-+		DUK_D(DUK_DPRINT("failed to add breakpoint for %O:%ld, all breakpoint slots used",
-+		                 (duk_heaphdr *) filename, (long) line));
-+		return -1;
-+	}
-+	heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL;
-+	b = heap->dbg_breakpoints + (heap->dbg_breakpoint_count++);
-+	b->filename = filename;
-+	b->line = line;
-+	DUK_HSTRING_INCREF(thr, filename);
-+
-+	return heap->dbg_breakpoint_count - 1;  /* index */
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_debug_remove_breakpoint(duk_hthread *thr, duk_small_uint_t breakpoint_index) {
-+	duk_heap *heap;
-+	duk_hstring *h;
-+	duk_breakpoint *b;
-+	duk_size_t move_size;
-+
-+	/* Caller must trigger recomputation of active breakpoint list.  To
-+	 * ensure stale values are not used if that doesn't happen, clear the
-+	 * active breakpoint list here.
-+	 */
-+
-+	DUK_ASSERT(thr != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT_DISABLE(breakpoint_index >= 0);  /* unsigned */
-+
-+	if (breakpoint_index >= heap->dbg_breakpoint_count) {
-+		DUK_D(DUK_DPRINT("invalid breakpoint index: %ld", (long) breakpoint_index));
-+		return 0;
-+	}
-+	b = heap->dbg_breakpoints + breakpoint_index;
-+
-+	h = b->filename;
-+	DUK_ASSERT(h != NULL);
-+
-+	move_size = sizeof(duk_breakpoint) * (heap->dbg_breakpoint_count - breakpoint_index - 1);
-+	if (move_size > 0) {
-+		DUK_MEMMOVE((void *) b,
-+		            (void *) (b + 1),
-+		            move_size);
-+	}
-+	heap->dbg_breakpoint_count--;
-+	heap->dbg_breakpoints_active[0] = (duk_breakpoint *) NULL;
-+
-+	DUK_HSTRING_DECREF(thr, h);  /* side effects */
-+
-+	/* Breakpoint entries above the used area are left as garbage. */
-+
-+	return 1;
-+}
-+
-+#undef DUK__SET_CONN_BROKEN
-+
-+#else  /* DUK_USE_DEBUGGER_SUPPORT */
-+
-+/* No debugger support. */
-+
-+#endif  /* DUK_USE_DEBUGGER_SUPPORT */
-+#line 1 "duk_error_augment.c"
-+/*
-+ *  Augmenting errors at their creation site and their throw site.
-+ *
-+ *  When errors are created, traceback data is added by built-in code
-+ *  and a user error handler (if defined) can process or replace the
-+ *  error.  Similarly, when errors are thrown, a user error handler
-+ *  (if defined) can process or replace the error.
-+ *
-+ *  Augmentation and other processing at error creation time is nice
-+ *  because an error is only created once, but it may be thrown and
-+ *  rethrown multiple times.  User error handler registered for processing
-+ *  an error at its throw site must be careful to handle rethrowing in
-+ *  a useful manner.
-+ *
-+ *  Error augmentation may throw an internal error (e.g. alloc error).
-+ *
-+ *  Ecmascript allows throwing any values, so all values cannot be
-+ *  augmented.  Currently, the built-in augmentation at error creation
-+ *  only augments error values which are Error instances (= have the
-+ *  built-in Error.prototype in their prototype chain) and are also
-+ *  extensible.  User error handlers have no limitations in this respect.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Helper for calling a user error handler.
-+ *
-+ *  'thr' must be the currently active thread; the error handler is called
-+ *  in its context.  The valstack of 'thr' must have the error value on
-+ *  top, and will be replaced by another error value based on the return
-+ *  value of the error handler.
-+ *
-+ *  The helper calls duk_handle_call() recursively in protected mode.
-+ *  Before that call happens, no longjmps should happen; as a consequence,
-+ *  we must assume that the valstack contains enough temporary space for
-+ *  arguments and such.
-+ *
-+ *  While the error handler runs, any errors thrown will not trigger a
-+ *  recursive error handler call (this is implemented using a heap level
-+ *  flag which will "follow" through any coroutines resumed inside the
-+ *  error handler).  If the error handler is not callable or throws an
-+ *  error, the resulting error replaces the original error (for Duktape
-+ *  internal errors, duk_error_throw.c further substitutes this error with
-+ *  a DoubleError which is not ideal).  This would be easy to change and
-+ *  even signal to the caller.
-+ *
-+ *  The user error handler is stored in 'Duktape.errCreate' or
-+ *  'Duktape.errThrow' depending on whether we're augmenting the error at
-+ *  creation or throw time.  There are several alternatives to this approach,
-+ *  see doc/error-objects.txt for discussion.
-+ *
-+ *  Note: since further longjmp()s may occur while calling the error handler
-+ *  (for many reasons, e.g. a labeled 'break' inside the handler), the
-+ *  caller can make no assumptions on the thr->heap->lj state after the
-+ *  call (this affects especially duk_error_throw.c).  This is not an issue
-+ *  as long as the caller writes to the lj state only after the error handler
-+ *  finishes.
-+ */
-+
-+#if defined(DUK_USE_ERRTHROW) || defined(DUK_USE_ERRCREATE)
-+DUK_LOCAL void duk__err_augment_user(duk_hthread *thr, duk_small_uint_t stridx_cb) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval *tv_hnd;
-+	duk_small_uint_t call_flags;
-+	duk_int_t rc;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT_DISABLE(stridx_cb >= 0);  /* unsigned */
-+	DUK_ASSERT(stridx_cb < DUK_HEAP_NUM_STRINGS);
-+
-+	if (DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap)) {
-+		DUK_DD(DUK_DDPRINT("recursive call to error handler, ignore"));
-+		return;
-+	}
-+
-+	/*
-+	 *  Check whether or not we have an error handler.
-+	 *
-+	 *  We must be careful of not triggering an error when looking up the
-+	 *  property.  For instance, if the property is a getter, we don't want
-+	 *  to call it, only plain values are allowed.  The value, if it exists,
-+	 *  is not checked.  If the value is not a function, a TypeError happens
-+	 *  when it is called and that error replaces the original one.
-+	 */
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, 4);  /* 3 entries actually needed below */
-+
-+	/* [ ... errval ] */
-+
-+	if (thr->builtins[DUK_BIDX_DUKTAPE] == NULL) {
-+		/* When creating built-ins, some of the built-ins may not be set
-+		 * and we want to tolerate that when throwing errors.
-+		 */
-+		DUK_DD(DUK_DDPRINT("error occurred when DUK_BIDX_DUKTAPE is NULL, ignoring"));
-+		return;
-+	}
-+	tv_hnd = duk_hobject_find_existing_entry_tval_ptr(thr->heap,
-+	                                                  thr->builtins[DUK_BIDX_DUKTAPE],
-+	                                                  DUK_HTHREAD_GET_STRING(thr, stridx_cb));
-+	if (tv_hnd == NULL) {
-+		DUK_DD(DUK_DDPRINT("error handler does not exist or is not a plain value: %!T",
-+		                   (duk_tval *) tv_hnd));
-+		return;
-+	}
-+	DUK_DDD(DUK_DDDPRINT("error handler dump (callability not checked): %!T",
-+	                     (duk_tval *) tv_hnd));
-+	duk_push_tval(ctx, tv_hnd);
-+
-+	/* [ ... errval errhandler ] */
-+
-+	duk_insert(ctx, -2);  /* -> [ ... errhandler errval ] */
-+	duk_push_undefined(ctx);
-+	duk_insert(ctx, -2);  /* -> [ ... errhandler undefined(= this) errval ] */
-+
-+	/* [ ... errhandler undefined errval ] */
-+
-+	/*
-+	 *  DUK_CALL_FLAG_IGNORE_RECLIMIT causes duk_handle_call() to ignore C
-+	 *  recursion depth limit (and won't increase it either).  This is
-+	 *  dangerous, but useful because it allows the error handler to run
-+	 *  even if the original error is caused by C recursion depth limit.
-+	 *
-+	 *  The heap level DUK_HEAP_FLAG_ERRHANDLER_RUNNING is set for the
-+	 *  duration of the error handler and cleared afterwards.  This flag
-+	 *  prevents the error handler from running recursively.  The flag is
-+	 *  heap level so that the flag properly controls even coroutines
-+	 *  launched by an error handler.  Since the flag is heap level, it is
-+	 *  critical to restore it correctly.
-+	 *
-+	 *  We ignore errors now: a success return and an error value both
-+	 *  replace the original error value.  (This would be easy to change.)
-+	 */
-+
-+	DUK_ASSERT(!DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap));  /* since no recursive error handler calls */
-+	DUK_HEAP_SET_ERRHANDLER_RUNNING(thr->heap);
-+
-+	call_flags = DUK_CALL_FLAG_PROTECTED |
-+	             DUK_CALL_FLAG_IGNORE_RECLIMIT;  /* protected, ignore reclimit, not constructor */
-+
-+	rc = duk_handle_call(thr,
-+	                     1,            /* num args */
-+	                     call_flags);  /* call_flags */
-+	DUK_UNREF(rc);  /* no need to check now: both success and error are OK */
-+
-+	DUK_ASSERT(DUK_HEAP_HAS_ERRHANDLER_RUNNING(thr->heap));
-+	DUK_HEAP_CLEAR_ERRHANDLER_RUNNING(thr->heap);
-+
-+	/* [ ... errval ] */
-+}
-+#endif  /* DUK_USE_ERRTHROW || DUK_USE_ERRHANDLE */
-+
-+/*
-+ *  Add tracedata to an error on the stack top.
-+ */
-+
-+#ifdef DUK_USE_TRACEBACKS
-+DUK_LOCAL void duk__add_traceback(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_small_uint_t depth;
-+	duk_int_t i, i_min;
-+	duk_uarridx_t arr_idx;
-+	duk_double_t d;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr_callstack != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* [ ... error ] */
-+
-+	/*
-+	 *  The traceback format is pretty arcane in an attempt to keep it compact
-+	 *  and cheap to create.  It may change arbitrarily from version to version.
-+	 *  It should be decoded/accessed through version specific accessors only.
-+	 *
-+	 *  See doc/error-objects.txt.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("adding traceback to object: %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	duk_push_array(ctx);  /* XXX: specify array size, as we know it */
-+	arr_idx = 0;
-+
-+	/* compiler SyntaxErrors (and other errors) come first; blame the source
-+	 * code file/line primarily.
-+	 */
-+	if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
-+		duk_push_hstring(ctx, thr->compile_ctx->h_filename);
-+		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-+		arr_idx++;
-+
-+		duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line);  /* (flags<<32) + (line), flags = 0 */
-+		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-+		arr_idx++;
-+	}
-+
-+	/* filename/line from C macros (__FILE__, __LINE__) are added as an
-+	 * entry with a special format: (string, number).  The number contains
-+	 * the line and flags.
-+	 */
-+
-+	/* XXX: optimize: allocate an array part to the necessary size (upwards
-+	 * estimate) and fill in the values directly into the array part; finally
-+	 * update 'length'.
-+	 */
-+
-+	/* XXX: using duk_put_prop_index() would cause obscure error cases when Array.prototype
-+	 * has write-protected array index named properties.  This was seen as DoubleErrors
-+	 * in e.g. some test262 test cases.  Using duk_xdef_prop_index() is better but heavier.
-+	 * The best fix is to fill in the tracedata directly into the array part.
-+	 */
-+
-+	/* [ ... error arr ] */
-+
-+	if (c_filename) {
-+		duk_push_string(ctx, c_filename);
-+		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-+		arr_idx++;
-+
-+		d = (noblame_fileline ? ((duk_double_t) DUK_TB_FLAG_NOBLAME_FILELINE) * DUK_DOUBLE_2TO32 : 0.0) +
-+		    (duk_double_t) c_line;
-+		duk_push_number(ctx, d);
-+		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-+		arr_idx++;
-+	}
-+
-+	/* traceback depth doesn't take into account the filename/line
-+	 * special handling above (intentional)
-+	 */
-+	depth = DUK_USE_TRACEBACK_DEPTH;
-+	i_min = (thr_callstack->callstack_top > (duk_size_t) depth ? (duk_int_t) (thr_callstack->callstack_top - depth) : 0);
-+	DUK_ASSERT(i_min >= 0);
-+
-+	/* [ ... error arr ] */
-+
-+	DUK_ASSERT(thr_callstack->callstack_top <= DUK_INT_MAX);  /* callstack limits */
-+	for (i = (duk_int_t) (thr_callstack->callstack_top - 1); i >= i_min; i--) {
-+		duk_uint32_t pc;
-+
-+		/*
-+		 *  Note: each API operation potentially resizes the callstack,
-+		 *  so be careful to re-lookup after every operation.  Currently
-+		 *  these is no issue because we don't store a temporary 'act'
-+		 *  pointer at all.  (This would be a non-issue if we operated
-+		 *  directly on the array part.)
-+		 */
-+
-+		/* [... arr] */
-+
-+		DUK_ASSERT_DISABLE(thr_callstack->callstack[i].pc >= 0);  /* unsigned */
-+
-+		/* Add function object. */
-+		duk_push_tval(ctx, &(thr_callstack->callstack + i)->tv_func);
-+		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-+		arr_idx++;
-+
-+		/* Add a number containing: pc, activation flags.
-+		 *
-+		 * PC points to next instruction, find offending PC.  Note that
-+		 * PC == 0 for native code.
-+		 */
-+		pc = thr_callstack->callstack[i].pc;
-+		if (pc > 0) {
-+			pc--;
-+		}
-+		DUK_ASSERT_DISABLE(pc >= 0);  /* unsigned */
-+		DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32);  /* assume PC is at most 32 bits and non-negative */
-+		d = ((duk_double_t) thr_callstack->callstack[i].flags) * DUK_DOUBLE_2TO32 + (duk_double_t) pc;
-+		duk_push_number(ctx, d);  /* -> [... arr num] */
-+		duk_xdef_prop_index_wec(ctx, -2, arr_idx);
-+		arr_idx++;
-+	}
-+
-+	/* XXX: set with duk_hobject_set_length() when tracedata is filled directly */
-+	duk_push_uint(ctx, (duk_uint_t) arr_idx);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_WC);
-+
-+	/* [ ... error arr ] */
-+
-+	duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_TRACEDATA);  /* -> [ ... error ] */
-+}
-+#endif  /* DUK_USE_TRACEBACKS */
-+
-+#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
-+DUK_LOCAL void duk__err_augment_builtin_throw(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_small_int_t noblame_fileline, duk_hobject *obj) {
-+	duk_context *ctx = (duk_context *) thr;
-+#ifdef DUK_USE_ASSERTIONS
-+	duk_int_t entry_top;
-+#endif
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	entry_top = duk_get_top(ctx);
-+#endif
-+	DUK_ASSERT(obj != NULL);
-+
-+	DUK_UNREF(obj);  /* unreferenced w/o tracebacks */
-+	DUK_UNREF(ctx);  /* unreferenced w/ tracebacks */
-+
-+#ifdef DUK_USE_TRACEBACKS
-+	/*
-+	 *  If tracebacks are enabled, the '_Tracedata' property is the only
-+	 *  thing we need: 'fileName' and 'lineNumber' are virtual properties
-+	 *  which use '_Tracedata'.
-+	 */
-+
-+	if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_TRACEDATA(thr))) {
-+		DUK_DDD(DUK_DDDPRINT("error value already has a '_Tracedata' property, not modifying it"));
-+	} else {
-+		duk__add_traceback(thr, thr_callstack, c_filename, c_line, noblame_fileline);
-+	}
-+#else
-+	/*
-+	 *  If tracebacks are disabled, 'fileName' and 'lineNumber' are added
-+	 *  as plain own properties.  Since Error.prototype has accessors of
-+	 *  the same name, we need to define own properties directly (cannot
-+	 *  just use e.g. duk_put_prop_stridx).  Existing properties are not
-+	 *  overwritten in case they already exist.
-+	 */
-+
-+	if (thr->compile_ctx != NULL && thr->compile_ctx->h_filename != NULL) {
-+		/* Compiler SyntaxError (or other error) gets the primary blame. */
-+		duk_push_hstring(ctx, thr->compile_ctx->h_filename);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
-+		duk_push_uint(ctx, (duk_uint_t) thr->compile_ctx->curr_token.start_line);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
-+	} else if (c_filename && !noblame_fileline) {
-+		/* XXX: file/line is disabled in minimal builds, so disable this too
-+		 * when appropriate.
-+		 */
-+		duk_push_string(ctx, c_filename);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
-+		duk_push_int(ctx, c_line);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
-+	} else if (thr_callstack->callstack_top > 0) {
-+		duk_activation *act;
-+		duk_hobject *func;
-+
-+		act = thr_callstack->callstack + thr_callstack->callstack_top - 1;
-+		DUK_ASSERT(act >= thr_callstack->callstack && act < thr_callstack->callstack + thr_callstack->callstack_size);
-+		func = DUK_ACT_GET_FUNC(act);
-+		if (func) {
-+			duk_uint32_t pc;
-+
-+			/* PC points to next instruction, find offending PC.  Note that
-+			 * PC == 0 for native code.
-+			 */
-+			pc = act->pc;
-+			if (pc > 0) {
-+				pc--;
-+			}
-+			DUK_ASSERT_DISABLE(pc >= 0);  /* unsigned */
-+			DUK_ASSERT((duk_double_t) pc < DUK_DOUBLE_2TO32);  /* assume PC is at most 32 bits and non-negative */
-+			act = NULL;  /* invalidated by pushes, so get out of the way */
-+
-+			duk_push_hobject(ctx, func);
-+
-+			/* [ ... error func ] */
-+
-+			duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME);
-+			duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
-+
-+#if defined(DUK_USE_PC2LINE)
-+			if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-+				duk_uint32_t ecma_line;
-+#if 0
-+				duk_push_u32(ctx, pc);
-+				duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_PC, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAGS_NO_OVERWRITE);
-+#endif
-+				ecma_line = duk_hobject_pc2line_query(ctx, -1, (duk_uint_fast32_t) pc);
-+				if (ecma_line > 0) {
-+					duk_push_u32(ctx, (duk_uint32_t) ecma_line); /* -> [ ... error func line ] */
-+					duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LINE_NUMBER, DUK_PROPDESC_FLAGS_WC | DUK_PROPDESC_FLAG_NO_OVERWRITE);
-+				}
-+			} else {
-+				/* Native function, no relevant lineNumber. */
-+			}
-+#endif  /* DUK_USE_PC2LINE */
-+
-+			duk_pop(ctx);
-+		}
-+	}
-+#endif  /* DUK_USE_TRACEBACKS */
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	DUK_ASSERT(duk_get_top(ctx) == entry_top);
-+#endif
-+}
-+#endif  /* DUK_USE_AUGMENT_ERROR_CREATE */
-+
-+/*
-+ *  Augment an error at creation time with _Tracedata/fileName/lineNumber
-+ *  and allow a user error handler (if defined) to process/replace the error.
-+ *  The error to be augmented is at the stack top.
-+ *
-+ *  thr: thread containing the error value
-+ *  thr_callstack: thread which should be used for generating callstack etc.
-+ *  c_filename: C __FILE__ related to the error
-+ *  c_line: C __LINE__ related to the error
-+ *  noblame_fileline: if true, don't fileName/line as error source, otherwise use traceback
-+ *                    (needed because user code filename/line are reported but internal ones
-+ *                    are not)
-+ *
-+ *  XXX: rename noblame_fileline to flags field; combine it to some existing
-+ *  field (there are only a few call sites so this may not be worth it).
-+ */
-+
-+#if defined(DUK_USE_AUGMENT_ERROR_CREATE)
-+DUK_INTERNAL void duk_err_augment_error_create(duk_hthread *thr, duk_hthread *thr_callstack, const char *c_filename, duk_int_t c_line, duk_bool_t noblame_fileline) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *obj;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr_callstack != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* [ ... error ] */
-+
-+	/*
-+	 *  Criteria for augmenting:
-+	 *
-+	 *   - augmentation enabled in build (naturally)
-+	 *   - error value internal prototype chain contains the built-in
-+	 *     Error prototype object (i.e. 'val instanceof Error')
-+	 *
-+	 *  Additional criteria for built-in augmenting:
-+	 *
-+	 *   - error value is an extensible object
-+	 */
-+
-+	obj = duk_get_hobject(ctx, -1);
-+	if (!obj) {
-+		DUK_DDD(DUK_DDDPRINT("value is not an object, skip both built-in and user augment"));
-+		return;
-+	}
-+	if (!duk_hobject_prototype_chain_contains(thr, obj, thr->builtins[DUK_BIDX_ERROR_PROTOTYPE], 1 /*ignore_loop*/)) {
-+		/* If the value has a prototype loop, it's critical not to
-+		 * throw here.  Instead, assume the value is not to be
-+		 * augmented.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("value is not an error instance, skip both built-in and user augment"));
-+		return;
-+	}
-+	if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) {
-+		DUK_DDD(DUK_DDDPRINT("error meets criteria, built-in augment"));
-+		duk__err_augment_builtin_throw(thr, thr_callstack, c_filename, c_line, noblame_fileline, obj);
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("error does not meet criteria, no built-in augment"));
-+	}
-+
-+	/* [ ... error ] */
-+
-+#if defined(DUK_USE_ERRCREATE)
-+	duk__err_augment_user(thr, DUK_STRIDX_ERR_CREATE);
-+#endif
-+}
-+#endif  /* DUK_USE_AUGMENT_ERROR_CREATE */
-+
-+/*
-+ *  Augment an error at throw time; allow a user error handler (if defined)
-+ *  to process/replace the error.  The error to be augmented is at the
-+ *  stack top.
-+ */
-+
-+#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-+DUK_INTERNAL void duk_err_augment_error_throw(duk_hthread *thr) {
-+#if defined(DUK_USE_ERRTHROW)
-+	duk__err_augment_user(thr, DUK_STRIDX_ERR_THROW);
-+#endif  /* DUK_USE_ERRTHROW */
-+}
-+#endif  /* DUK_USE_AUGMENT_ERROR_THROW */
-+#line 1 "duk_error_longjmp.c"
-+/*
-+ *  Do a longjmp call, calling the fatal error handler if no
-+ *  catchpoint exists.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL void duk_err_longjmp(duk_hthread *thr) {
-+	DUK_ASSERT(thr != NULL);
-+
-+	if (!thr->heap->lj.jmpbuf_ptr) {
-+		/*
-+		 *  If we don't have a jmpbuf_ptr, there is little we can do
-+		 *  except panic.  The caller's expectation is that we never
-+		 *  return.
-+		 */
-+
-+		DUK_D(DUK_DPRINT("uncaught error: type=%d iserror=%d value1=%!T value2=%!T",
-+		                 (int) thr->heap->lj.type, (int) thr->heap->lj.iserror,
-+		                 &thr->heap->lj.value1, &thr->heap->lj.value2));
-+
-+		duk_fatal((duk_context *) thr, DUK_ERR_UNCAUGHT_ERROR, "uncaught error");
-+		DUK_UNREACHABLE();
-+	}
-+
-+	DUK_LONGJMP(thr->heap->lj.jmpbuf_ptr->jb);
-+	DUK_UNREACHABLE();
-+}
-+#line 1 "duk_error_misc.c"
-+/*
-+ *  Error helpers
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Get prototype object for an integer error code.
-+ */
-+
-+DUK_INTERNAL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t code) {
-+	switch (code) {
-+	case DUK_ERR_EVAL_ERROR:
-+		return thr->builtins[DUK_BIDX_EVAL_ERROR_PROTOTYPE];
-+	case DUK_ERR_RANGE_ERROR:
-+		return thr->builtins[DUK_BIDX_RANGE_ERROR_PROTOTYPE];
-+	case DUK_ERR_REFERENCE_ERROR:
-+		return thr->builtins[DUK_BIDX_REFERENCE_ERROR_PROTOTYPE];
-+	case DUK_ERR_SYNTAX_ERROR:
-+		return thr->builtins[DUK_BIDX_SYNTAX_ERROR_PROTOTYPE];
-+	case DUK_ERR_TYPE_ERROR:
-+		return thr->builtins[DUK_BIDX_TYPE_ERROR_PROTOTYPE];
-+	case DUK_ERR_URI_ERROR:
-+		return thr->builtins[DUK_BIDX_URI_ERROR_PROTOTYPE];
-+
-+	/* XXX: more specific error classes? */
-+	case DUK_ERR_UNIMPLEMENTED_ERROR:
-+	case DUK_ERR_INTERNAL_ERROR:
-+	case DUK_ERR_ALLOC_ERROR:
-+	case DUK_ERR_ASSERTION_ERROR:
-+	case DUK_ERR_API_ERROR:
-+	case DUK_ERR_ERROR:
-+	default:
-+		return thr->builtins[DUK_BIDX_ERROR_PROTOTYPE];
-+	}
-+}
-+
-+/*
-+ *  Exposed helper for setting up heap longjmp state.
-+ */
-+
-+DUK_INTERNAL void duk_err_setup_heap_ljstate(duk_hthread *thr, duk_small_int_t lj_type) {
-+	duk_tval tv_tmp;
-+
-+	thr->heap->lj.type = lj_type;
-+
-+	DUK_ASSERT(thr->valstack_top > thr->valstack);
-+	DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1);
-+	DUK_TVAL_SET_TVAL(&thr->heap->lj.value1, thr->valstack_top - 1);
-+	DUK_TVAL_INCREF(thr, &thr->heap->lj.value1);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+	duk_pop((duk_context *) thr);
-+}
-+#line 1 "duk_error_throw.c"
-+/*
-+ *  Create and throw an Ecmascript error object based on a code and a message.
-+ *
-+ *  Used when we throw errors internally.  Ecmascript generated error objects
-+ *  are created by Ecmascript code, and the throwing is handled by the bytecode
-+ *  executor.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Create and throw an error (originating from Duktape internally)
-+ *
-+ *  Push an error object on top of the stack, possibly throw augmenting
-+ *  the error, and finally longjmp.
-+ *
-+ *  If an error occurs while we're dealing with the current error, we might
-+ *  enter an infinite recursion loop.  This is prevented by detecting a
-+ *  "double fault" through the heap->handling_error flag; the recursion
-+ *  then stops at the second level.
-+ */
-+
-+#ifdef DUK_USE_VERBOSE_ERRORS
-+DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code, const char *msg, const char *filename, duk_int_t line) {
-+#else
-+DUK_INTERNAL void duk_err_create_and_throw(duk_hthread *thr, duk_errcode_t code) {
-+#endif
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_bool_t double_error = thr->heap->handling_error;
-+
-+#ifdef DUK_USE_VERBOSE_ERRORS
-+	DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld, msg=%s, filename=%s, line=%ld",
-+	                   (long) code, (const char *) msg,
-+	                   (const char *) filename, (long) line));
-+#else
-+	DUK_DD(DUK_DDPRINT("duk_err_create_and_throw(): code=%ld", (long) code));
-+#endif
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+
-+	thr->heap->handling_error = 1;
-+
-+	/*
-+	 *  Create and push an error object onto the top of stack.
-+	 *  If a "double error" occurs, use a fixed error instance
-+	 *  to avoid further trouble.
-+	 */
-+
-+	/* XXX: if attempt to push beyond allocated valstack, this double fault
-+	 * handling fails miserably.  We should really write the double error
-+	 * directly to thr->heap->lj.value1 and avoid valstack use entirely.
-+	 */
-+
-+	if (double_error) {
-+		if (thr->builtins[DUK_BIDX_DOUBLE_ERROR]) {
-+			DUK_D(DUK_DPRINT("double fault detected -> push built-in fixed 'double error' instance"));
-+			duk_push_hobject_bidx(ctx, DUK_BIDX_DOUBLE_ERROR);
-+		} else {
-+			DUK_D(DUK_DPRINT("double fault detected; there is no built-in fixed 'double error' instance "
-+			                 "-> push the error code as a number"));
-+			duk_push_int(ctx, (duk_int_t) code);
-+		}
-+	} else {
-+		/* Error object is augmented at its creation here. */
-+		duk_require_stack(ctx, 1);
-+		/* XXX: unnecessary '%s' formatting here, but cannot use
-+		 * 'msg' as a format string directly.
-+		 */
-+#ifdef DUK_USE_VERBOSE_ERRORS
-+		duk_push_error_object_raw(ctx,
-+		                          code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE,
-+		                          filename,
-+		                          line,
-+		                          "%s",
-+		                          (const char *) msg);
-+#else
-+		duk_push_error_object_raw(ctx,
-+		                          code | DUK_ERRCODE_FLAG_NOBLAME_FILELINE,
-+		                          NULL,
-+		                          0,
-+		                          NULL);
-+#endif
-+	}
-+
-+	/*
-+	 *  Augment error (throw time), unless alloc/double error
-+	 */
-+
-+	if (double_error || code == DUK_ERR_ALLOC_ERROR) {
-+		DUK_D(DUK_DPRINT("alloc or double error: skip throw augmenting to avoid further trouble"));
-+	} else {
-+#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-+		DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT (before throw augment)",
-+		                     (duk_tval *) duk_get_tval(ctx, -1)));
-+		duk_err_augment_error_throw(thr);
-+#endif
-+	}
-+
-+	/*
-+	 *  Finally, longjmp
-+	 */
-+
-+	thr->heap->handling_error = 0;
-+
-+	duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
-+
-+	DUK_DDD(DUK_DDDPRINT("THROW ERROR (INTERNAL): %!iT, %!iT (after throw augment)",
-+	                     (duk_tval *) &thr->heap->lj.value1, (duk_tval *) &thr->heap->lj.value2));
-+
-+	duk_err_longjmp(thr);
-+	DUK_UNREACHABLE();
-+}
-+
-+/*
-+ *  Helper for C function call negative return values.
-+ */
-+
-+DUK_INTERNAL void duk_error_throw_from_negative_rc(duk_hthread *thr, duk_ret_t rc) {
-+	duk_context *ctx = (duk_context *) thr;
-+	const char *msg;
-+	duk_errcode_t code;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(rc < 0);
-+
-+	/* XXX: this generates quite large code - perhaps select the error
-+	 * class based on the code and then just use the error 'name'?
-+	 */
-+
-+	code = -rc;
-+
-+	switch (rc) {
-+	case DUK_RET_UNIMPLEMENTED_ERROR:  msg = "unimplemented"; break;
-+	case DUK_RET_UNSUPPORTED_ERROR:    msg = "unsupported"; break;
-+	case DUK_RET_INTERNAL_ERROR:       msg = "internal"; break;
-+	case DUK_RET_ALLOC_ERROR:          msg = "alloc"; break;
-+	case DUK_RET_ASSERTION_ERROR:      msg = "assertion"; break;
-+	case DUK_RET_API_ERROR:            msg = "api"; break;
-+	case DUK_RET_UNCAUGHT_ERROR:       msg = "uncaught"; break;
-+	case DUK_RET_ERROR:                msg = "error"; break;
-+	case DUK_RET_EVAL_ERROR:           msg = "eval"; break;
-+	case DUK_RET_RANGE_ERROR:          msg = "range"; break;
-+	case DUK_RET_REFERENCE_ERROR:      msg = "reference"; break;
-+	case DUK_RET_SYNTAX_ERROR:         msg = "syntax"; break;
-+	case DUK_RET_TYPE_ERROR:           msg = "type"; break;
-+	case DUK_RET_URI_ERROR:            msg = "uri"; break;
-+	default:                           msg = "unknown"; break;
-+	}
-+
-+	DUK_ASSERT(msg != NULL);
-+
-+	/*
-+	 *  The __FILE__ and __LINE__ information is intentionally not used in the
-+	 *  creation of the error object, as it isn't useful in the tracedata.  The
-+	 *  tracedata still contains the function which returned the negative return
-+	 *  code, and having the file/line of this function isn't very useful.
-+	 */
-+
-+	duk_error_raw(ctx, code, NULL, 0, "%s error (rc %ld)", (const char *) msg, (long) rc);
-+	DUK_UNREACHABLE();
-+}
-+#line 1 "duk_hbuffer_alloc.c"
-+/*
-+ *  duk_hbuffer allocation and freeing.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags) {
-+	duk_hbuffer *res = NULL;
-+	duk_size_t alloc_size;
-+
-+	DUK_DDD(DUK_DDDPRINT("allocate hbuffer"));
-+
-+	/* Size sanity check.  Should not be necessary because caller is
-+	 * required to check this, but we don't want to cause a segfault
-+	 * if the size wraps either in duk_size_t computation or when
-+	 * storing the size in a 16-bit field.
-+	 */
-+	if (size > DUK_HBUFFER_MAX_BYTELEN) {
-+		DUK_D(DUK_DPRINT("hbuffer alloc failed: size too large: %ld", (long) size));
-+		return NULL;
-+	}
-+
-+	if (flags & DUK_BUF_FLAG_DYNAMIC) {
-+		alloc_size = sizeof(duk_hbuffer_dynamic);
-+	} else {
-+		alloc_size = sizeof(duk_hbuffer_fixed) + size;
-+		DUK_ASSERT(alloc_size >= sizeof(duk_hbuffer_fixed));  /* no wrapping */
-+	}
-+
-+	res = (duk_hbuffer *) DUK_ALLOC(heap, alloc_size);
-+	if (!res) {
-+		goto error;
-+	}
-+
-+	/* zero everything unless requested not to do so */
-+#if defined(DUK_USE_ZERO_BUFFER_DATA)
-+	DUK_MEMZERO((void *) res,
-+	            (flags & DUK_BUF_FLAG_NOZERO) ?
-+	                ((flags & DUK_BUF_FLAG_DYNAMIC) ?
-+	                     sizeof(duk_hbuffer_dynamic) :
-+	                     sizeof(duk_hbuffer_fixed)) :
-+	                alloc_size);
-+#else
-+	DUK_MEMZERO((void *) res,
-+	            (flags & DUK_BUF_FLAG_DYNAMIC) ? sizeof(duk_hbuffer_dynamic) : sizeof(duk_hbuffer_fixed));
-+#endif
-+
-+	if (flags & DUK_BUF_FLAG_DYNAMIC) {
-+		duk_hbuffer_dynamic *h = (duk_hbuffer_dynamic *) res;
-+		void *ptr;
-+		if (size > 0) {
-+			DUK_DDD(DUK_DDDPRINT("dynamic buffer with nonzero size, alloc actual buffer"));
-+#ifdef DUK_USE_ZERO_BUFFER_DATA
-+			ptr = DUK_ALLOC_ZEROED(heap, size);
-+#else
-+			ptr = DUK_ALLOC(heap, size);
-+#endif
-+			if (!ptr) {
-+				/* Because size > 0, NULL check is correct */
-+				goto error;
-+			}
-+
-+			DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, ptr);
-+			DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(h, size);  /* snug */
-+		} else {
-+#if defined(DUK_USE_EXPLICIT_NULL_INIT)
-+#if defined(DUK_USE_HEAPPTR16)
-+/* the compressed pointer is zeroed which maps to NULL, so nothing to do. */
-+#else
-+			DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, h, NULL);
-+#endif
-+#endif
-+			DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, h) == NULL);
-+			DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(h) == 0);
-+		}
-+	}
-+
-+	DUK_HBUFFER_SET_SIZE(res, size);
-+
-+	DUK_HEAPHDR_SET_TYPE(&res->hdr, DUK_HTYPE_BUFFER);
-+	if (flags & DUK_BUF_FLAG_DYNAMIC) {
-+		DUK_HBUFFER_SET_DYNAMIC(res);
-+	}
-+        DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &res->hdr);
-+
-+	DUK_DDD(DUK_DDDPRINT("allocated hbuffer: %p", (void *) res));
-+	return res;
-+
-+ error:
-+	DUK_DD(DUK_DDPRINT("hbuffer allocation failed"));
-+
-+	DUK_FREE(heap, res);
-+	return NULL;
-+}
-+
-+/* For indirect allocs. */
-+
-+DUK_INTERNAL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud) {
-+	duk_hbuffer_dynamic *buf = (duk_hbuffer_dynamic *) ud;
-+	DUK_UNREF(heap);
-+	return (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, buf);
-+}
-+#line 1 "duk_hbuffer_ops.c"
-+/*
-+ *  duk_hbuffer operations such as resizing and inserting/appending data to
-+ *  a dynamic buffer.
-+ *
-+ *  Append operations append to the end of the buffer and they are relatively
-+ *  efficient: the buffer is grown with a "spare" part relative to the buffer
-+ *  size to minimize reallocations.  Insert operations need to move existing
-+ *  data forward in the buffer with memmove() and are not very efficient.
-+ *  They are used e.g. by the regexp compiler to "backpatch" regexp bytecode.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Resizing
-+ */
-+
-+DUK_LOCAL duk_size_t duk__add_spare(duk_size_t size) {
-+	duk_size_t spare = (size / DUK_HBUFFER_SPARE_DIVISOR) + DUK_HBUFFER_SPARE_ADD;
-+	duk_size_t res;
-+
-+	res = size + spare;
-+	if (res < size) {
-+		/* XXX: handle corner cases where size is close to size limit (wraparound) */
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "duk_size_t wrapped");
-+	}
-+	DUK_ASSERT(res >= size);
-+
-+	return res;
-+}
-+
-+DUK_INTERNAL void duk_hbuffer_resize(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t new_size, duk_size_t new_alloc_size) {
-+	void *res;
-+	duk_size_t prev_alloc_size;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(new_alloc_size >= new_size);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	/*
-+	 *  Maximum size check
-+	 */
-+
-+	if (new_alloc_size > DUK_HBUFFER_MAX_BYTELEN) {
-+		DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "buffer too long");
-+	}
-+
-+	/*
-+	 *  Note: use indirect realloc variant just in case mark-and-sweep
-+	 *  (finalizers) might resize this same buffer during garbage
-+	 *  collection.
-+	 */
-+
-+	res = DUK_REALLOC_INDIRECT(thr->heap, duk_hbuffer_get_dynalloc_ptr, (void *) buf, new_alloc_size);
-+	if (res != NULL || new_alloc_size == 0) {
-+		/* 'res' may be NULL if new allocation size is 0. */
-+
-+		DUK_DDD(DUK_DDDPRINT("resized dynamic buffer %p:%ld:%ld -> %p:%ld:%ld",
-+		                     (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf),
-+		                     (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf),
-+		                     (long) DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(buf),
-+		                     (void *) res,
-+		                     (long) new_size,
-+		                     (long) new_alloc_size));
-+
-+		/*
-+		 *  The entire allocated buffer area, regardless of actual used
-+		 *  size, is kept zeroed in resizes for simplicity.  If the buffer
-+		 *  is grown, zero the new part.  Another policy would be to
-+		 *  ensure data is zeroed as the used part is extended.  The
-+		 *  current approach is much more simple and is not a big deal
-+		 *  because the spare part is relatively small.
-+		 */
-+
-+		prev_alloc_size = DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(buf);
-+		if (new_alloc_size > prev_alloc_size) {
-+			DUK_ASSERT(new_alloc_size - prev_alloc_size > 0);
-+#ifdef DUK_USE_ZERO_BUFFER_DATA
-+			DUK_MEMZERO((void *) ((char *) res + prev_alloc_size),
-+			            new_alloc_size - prev_alloc_size);
-+#endif
-+		}
-+
-+		DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, new_size);
-+		DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(buf, new_alloc_size);
-+		DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(thr->heap, buf, res);
-+	} else {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "buffer resize failed: %ld:%ld to %ld:%ld",
-+		          (long) DUK_HBUFFER_DYNAMIC_GET_SIZE(buf),
-+		          (long) DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(buf),
-+		          (long) new_size,
-+		          (long) new_alloc_size);
-+	}
-+
-+	DUK_ASSERT(res != NULL || new_alloc_size == 0);
-+}
-+
-+DUK_INTERNAL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	duk_hbuffer_resize(thr, buf, 0, 0);
-+}
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL void duk_hbuffer_compact(duk_hthread *thr, duk_hbuffer_dynamic *buf) {
-+	duk_size_t curr_size;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	curr_size = DUK_HBUFFER_GET_SIZE(buf);
-+	duk_hbuffer_resize(thr, buf, curr_size, curr_size);
-+}
-+#endif
-+
-+/*
-+ *  Inserts
-+ */
-+
-+DUK_INTERNAL void duk_hbuffer_insert_bytes(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, const duk_uint8_t *data, duk_size_t length) {
-+	duk_uint8_t *p;
-+
-+	/* XXX: allow inserts with offset > curr_size? i.e., insert zeroes automatically? */
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	DUK_ASSERT_DISABLE(offset >= 0);  /* unsigned, so always true */
-+	DUK_ASSERT(offset <= DUK_HBUFFER_GET_SIZE(buf));  /* equality is OK (= append) */
-+	DUK_ASSERT(data != NULL);
-+	DUK_ASSERT_DISABLE(length >= 0);  /* unsigned, so always true */
-+
-+	if (length == 0) {
-+		return;
-+	}
-+
-+	if (DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) < length) {
-+		duk_hbuffer_resize(thr,
-+		                   buf,
-+		                   DUK_HBUFFER_GET_SIZE(buf),
-+		                   duk__add_spare(DUK_HBUFFER_GET_SIZE(buf) + length));
-+	}
-+	DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) >= length);
-+
-+	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf);
-+	if (offset < DUK_HBUFFER_GET_SIZE(buf)) {
-+		/* not an append */
-+
-+		DUK_ASSERT(DUK_HBUFFER_GET_SIZE(buf) - offset > 0);
-+		DUK_MEMMOVE((void *) (p + offset + length),
-+		            (void *) (p + offset),
-+		            DUK_HBUFFER_GET_SIZE(buf) - offset);
-+	}
-+
-+	DUK_ASSERT(length > 0);
-+	DUK_MEMCPY((void *) (p + offset),
-+	           data,
-+	           length);
-+
-+	DUK_HBUFFER_DYNAMIC_ADD_SIZE(buf, length);
-+}
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL void duk_hbuffer_insert_byte(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_uint8_t byte) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	duk_hbuffer_insert_bytes(thr, buf, offset, &byte, 1);
-+}
-+#endif
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL duk_size_t duk_hbuffer_insert_cstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, const char *str) {
-+	duk_size_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(str != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	len = DUK_STRLEN(str);
-+	duk_hbuffer_insert_bytes(thr, buf, offset, (duk_uint8_t *) str, len);
-+	return len;
-+}
-+#endif
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL duk_size_t duk_hbuffer_insert_hstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_hstring *str) {
-+	duk_size_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(str != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	len = DUK_HSTRING_GET_BYTELEN(str);
-+	duk_hbuffer_insert_bytes(thr, buf, offset, (duk_uint8_t *) DUK_HSTRING_GET_DATA(str), len);
-+	return len;
-+}
-+#endif
-+
-+DUK_INTERNAL duk_size_t duk_hbuffer_insert_xutf8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_ucodepoint_t codepoint) {
-+	duk_uint8_t tmp[DUK_UNICODE_MAX_XUTF8_LENGTH];
-+	duk_size_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	/* No range assertion for 'codepoint' */
-+
-+	/* Intentionally no fast path: insertion is not that central */
-+
-+	len = (duk_size_t) duk_unicode_encode_xutf8(codepoint, tmp);
-+	duk_hbuffer_insert_bytes(thr, buf, offset, tmp, len);
-+	return len;
-+}
-+
-+/* Append a Unicode codepoint to the buffer in CESU-8 format, i.e., convert
-+ * non-BMP characters to surrogate pairs which are then "UTF-8" encoded.
-+ * If the codepoint is initially a surrogate, it is also encoded into CESU-8.
-+ * Codepoints above valid Unicode range (> U+10FFFF) are mangled.
-+ */
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL duk_size_t duk_hbuffer_insert_cesu8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_ucodepoint_t codepoint) {
-+	duk_uint8_t tmp[DUK_UNICODE_MAX_CESU8_LENGTH];
-+	duk_size_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	DUK_ASSERT_DISABLE(codepoint >= 0);  /* unsigned */
-+	DUK_ASSERT(codepoint <= 0x10ffff);  /* if not in this range, results are garbage (but no crash) */
-+
-+	/* Intentionally no fast path: insertion is not that central */
-+
-+	len = (duk_size_t) duk_unicode_encode_cesu8(codepoint, tmp);
-+	duk_hbuffer_insert_bytes(thr, buf, offset, tmp, len);
-+	return len;
-+}
-+#endif
-+
-+/*
-+ *  Appends
-+ *
-+ *  Note: an optimized duk_hbuffer_append_bytes() could be implemented, but
-+ *  it is more compact to use duk_hbuffer_insert_bytes() instead.  The
-+ *  important fast paths bypass these functions. anyway.
-+ */
-+
-+DUK_INTERNAL void duk_hbuffer_append_bytes(duk_hthread *thr, duk_hbuffer_dynamic *buf, const duk_uint8_t *data, duk_size_t length) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	DUK_ASSERT(data != NULL);
-+
-+	duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), data, length);
-+}
-+
-+DUK_INTERNAL void duk_hbuffer_append_byte(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_uint8_t byte) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), &byte, 1);
-+}
-+
-+DUK_INTERNAL duk_size_t duk_hbuffer_append_cstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, const char *str) {
-+	duk_size_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(str != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	len = DUK_STRLEN(str);
-+	duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), (duk_uint8_t *) str, len);
-+	return len;
-+}
-+
-+DUK_INTERNAL duk_size_t duk_hbuffer_append_hstring(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_hstring *str) {
-+	duk_size_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(str != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+
-+	len = DUK_HSTRING_GET_BYTELEN(str);
-+	duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), (duk_uint8_t *) DUK_HSTRING_GET_DATA(str), len);
-+	return len;
-+}
-+
-+/* Append a Unicode codepoint to the buffer in extended UTF-8 format, i.e.
-+ * allow codepoints above standard Unicode range (> U+10FFFF) up to seven
-+ * byte encoding (36 bits, but argument type is 32 bits).  In particular,
-+ * allows encoding of all unsigned 32-bit integers.  If the codepoint is
-+ * initially a surrogate, it is encoded without checking (and will become,
-+ * effectively, CESU-8 encoded).
-+ */
-+
-+DUK_INTERNAL duk_size_t duk_hbuffer_append_xutf8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_ucodepoint_t codepoint) {
-+	duk_uint8_t tmp[DUK_UNICODE_MAX_XUTF8_LENGTH];
-+	duk_size_t len;
-+	duk_size_t sz;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	/* No range assertion for 'codepoint' */
-+
-+	if (DUK_LIKELY(codepoint < 0x80 && DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) > 0)) {
-+		/* fast path: ASCII and there is spare */
-+		duk_uint8_t *p = ((duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf));
-+		sz = DUK_HBUFFER_DYNAMIC_GET_SIZE(buf);
-+		p[sz++] = (duk_uint8_t) codepoint;
-+		DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, sz);
-+		return 1;
-+	}
-+
-+	len = (duk_size_t) duk_unicode_encode_xutf8(codepoint, tmp);
-+	duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), tmp, len);
-+	return len;
-+}
-+
-+/* Append a Unicode codepoint to the buffer in CESU-8 format, i.e., convert
-+ * non-BMP characters to surrogate pairs which are then "UTF-8" encoded.
-+ * If the codepoint is initially a surrogate, it is also encoded into CESU-8.
-+ * Codepoints above valid Unicode range (> U+10FFFF) are mangled.
-+ */
-+
-+DUK_INTERNAL duk_size_t duk_hbuffer_append_cesu8(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_ucodepoint_t codepoint) {
-+	duk_uint8_t tmp[DUK_UNICODE_MAX_CESU8_LENGTH];
-+	duk_size_t len;
-+	duk_size_t sz;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	DUK_ASSERT_DISABLE(codepoint >= 0);  /* unsigned */
-+	DUK_ASSERT(codepoint <= 0x10ffff);  /* if not in this range, results are garbage (but no crash) */
-+
-+	if (DUK_LIKELY(codepoint < 0x80 && DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) > 0)) {
-+		/* fast path: ASCII and there is spare */
-+		duk_uint8_t *p = ((duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf));
-+		sz = DUK_HBUFFER_DYNAMIC_GET_SIZE(buf);
-+		p[sz++] = (duk_uint8_t) codepoint;
-+		DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, sz);
-+		return 1;
-+	}
-+
-+	len = (duk_size_t) duk_unicode_encode_cesu8(codepoint, tmp);
-+	duk_hbuffer_insert_bytes(thr, buf, DUK_HBUFFER_GET_SIZE(buf), tmp, len);
-+	return len;
-+}
-+
-+/* Append an duk_uint32_t in native byte order. */
-+#if 0  /*unused*/
-+DUK_INTERNAL void duk_hbuffer_append_native_u32(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_uint32_t val) {
-+	/* relies on duk_uint32_t being exactly right size */
-+	DUK_ASSERT(sizeof(val) == 4);
-+	duk_hbuffer_insert_bytes(thr,
-+	                         buf,
-+	                         DUK_HBUFFER_GET_SIZE(buf),
-+	                         (duk_uint8_t *) &val,
-+	                         sizeof(duk_uint32_t));
-+}
-+#endif
-+
-+/*
-+ *  In-buffer "slices"
-+ *
-+ *  Slices are identified with an offset+length pair, referring to the current
-+ *  buffer data.  A caller cannot otherwise reliably refer to existing data,
-+ *  because the buffer may be reallocated before a data pointer is referenced.
-+ */
-+
-+DUK_INTERNAL void duk_hbuffer_remove_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t offset, duk_size_t length) {
-+	duk_uint8_t *p;
-+	duk_size_t end_offset;
-+
-+	DUK_UNREF(thr);
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	DUK_ASSERT_DISABLE(offset >= 0);                               /* always true */
-+	DUK_ASSERT(offset <= DUK_HBUFFER_GET_SIZE(buf));               /* allow equality */
-+	DUK_ASSERT_DISABLE(length >= 0);                               /* always true */
-+	DUK_ASSERT(offset + length <= DUK_HBUFFER_GET_SIZE(buf));      /* allow equality */
-+
-+	if (length == 0) {
-+		return;
-+	}
-+
-+	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf);
-+
-+	end_offset = offset + length;
-+
-+	if (end_offset < DUK_HBUFFER_GET_SIZE(buf)) {
-+		/* not strictly from end of buffer; need to shuffle data */
-+		DUK_ASSERT(DUK_HBUFFER_GET_SIZE(buf) - end_offset > 0);
-+		DUK_MEMMOVE(p + offset,
-+		            p + end_offset,
-+		            DUK_HBUFFER_GET_SIZE(buf) - end_offset);
-+	}
-+
-+	/* Here we want to zero data even with automatic buffer zeroing
-+	 * disabled as we depend on this internally too.
-+	 */
-+	DUK_ASSERT(length > 0);
-+	DUK_MEMZERO(p + DUK_HBUFFER_GET_SIZE(buf) - length,
-+	            length);
-+
-+	DUK_HBUFFER_DYNAMIC_SUB_SIZE(buf, length);
-+
-+	/* Note: no shrink check, intentional */
-+}
-+
-+DUK_INTERNAL void duk_hbuffer_insert_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t dst_offset, duk_size_t src_offset, duk_size_t length) {
-+	duk_uint8_t *p;
-+	duk_size_t src_end_offset;  /* source end (exclusive) in initial buffer */
-+	duk_size_t len;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	DUK_ASSERT_DISABLE(dst_offset >= 0);                           /* always true */
-+	DUK_ASSERT(dst_offset <= DUK_HBUFFER_GET_SIZE(buf));           /* allow equality */
-+	DUK_ASSERT_DISABLE(src_offset >= 0);                           /* always true */
-+	DUK_ASSERT(src_offset <= DUK_HBUFFER_GET_SIZE(buf));           /* allow equality */
-+	DUK_ASSERT_DISABLE(length >= 0);                               /* always true */
-+	DUK_ASSERT(src_offset + length <= DUK_HBUFFER_GET_SIZE(buf));  /* allow equality */
-+
-+	if (length == 0) {
-+		return;
-+	}
-+
-+	if (DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) < length) {
-+		duk_hbuffer_resize(thr,
-+		                   buf,
-+		                   DUK_HBUFFER_GET_SIZE(buf),
-+		                   duk__add_spare(DUK_HBUFFER_GET_SIZE(buf) + length));
-+	}
-+	DUK_ASSERT(DUK_HBUFFER_DYNAMIC_GET_SPARE_SIZE(buf) >= length);
-+
-+	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, buf);
-+	DUK_ASSERT(p != NULL);  /* must be the case because length > 0, and buffer has been resized if necessary */
-+
-+	/*
-+	 *  src_offset and dst_offset refer to the state of the buffer
-+	 *  before any changes are made.  This must be taken into account
-+	 *  when moving data around; in particular, the source data may
-+	 *  "straddle" the dst_offset, so the insert may need to be handled
-+	 *  in two pieces.
-+	 */
-+
-+	src_end_offset = src_offset + length;
-+
-+	/* create a hole for the insert */
-+	len = DUK_HBUFFER_GET_SIZE(buf) - dst_offset;
-+	DUK_MEMMOVE(p + dst_offset + length,
-+	            p + dst_offset,
-+	            len);  /* zero size is not an issue: pointers are valid */
-+
-+	if (src_offset < dst_offset) {
-+		if (src_end_offset <= dst_offset) {
-+			/* entire source is before 'dst_offset' */
-+			DUK_MEMCPY(p + dst_offset,
-+			           p + src_offset,
-+			           length);
-+		} else {
-+			/* part of the source is before 'dst_offset'; straddles */
-+			len = dst_offset - src_offset;
-+			DUK_ASSERT(len >= 1 && len < length);
-+			DUK_ASSERT(length - len >= 1);
-+			DUK_MEMCPY(p + dst_offset,
-+			           p + src_offset,
-+			           len);
-+			DUK_MEMCPY(p + dst_offset + len,
-+			           p + src_offset + length + len,  /* take above memmove() into account */
-+			           length - len);
-+		}
-+	} else {
-+		/* entire source is after 'dst_offset' */
-+		DUK_MEMCPY(p + dst_offset,
-+		           p + src_offset + length,  /* take above memmove() into account */
-+		           length);
-+	}
-+
-+	DUK_HBUFFER_DYNAMIC_ADD_SIZE(buf, length);
-+}
-+
-+DUK_INTERNAL void duk_hbuffer_append_slice(duk_hthread *thr, duk_hbuffer_dynamic *buf, duk_size_t src_offset, duk_size_t length) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+	DUK_ASSERT_DISABLE(src_offset >= 0);                           /* always true */
-+	DUK_ASSERT(src_offset <= DUK_HBUFFER_GET_SIZE(buf));           /* allow equality */
-+	DUK_ASSERT_DISABLE(length >= 0);                               /* always true */
-+	DUK_ASSERT(src_offset + length <= DUK_HBUFFER_GET_SIZE(buf));  /* allow equality */
-+
-+	duk_hbuffer_insert_slice(thr,
-+	                         buf,
-+	                         DUK_HBUFFER_GET_SIZE(buf),
-+	                         src_offset,
-+	                         length);
-+}
-+#line 1 "duk_heap_alloc.c"
-+/*
-+ *  duk_heap allocation and freeing.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* constants for built-in string data depacking */
-+#define DUK__BITPACK_LETTER_LIMIT  26
-+#define DUK__BITPACK_UNDERSCORE    26
-+#define DUK__BITPACK_FF            27
-+#define DUK__BITPACK_SWITCH1       29
-+#define DUK__BITPACK_SWITCH        30
-+#define DUK__BITPACK_SEVENBIT      31
-+
-+/*
-+ *  Free a heap object.
-+ *
-+ *  Free heap object and its internal (non-heap) pointers.  Assumes that
-+ *  caller has removed the object from heap allocated list or the string
-+ *  intern table, and any weak references (which strings may have) have
-+ *  been already dealt with.
-+ */
-+
-+DUK_INTERNAL void duk_free_hobject_inner(duk_heap *heap, duk_hobject *h) {
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(h != NULL);
-+
-+	DUK_FREE(heap, DUK_HOBJECT_GET_PROPS(heap, h));
-+
-+	if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
-+		duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
-+		DUK_UNREF(f);
-+		/* Currently nothing to free; 'data' is a heap object */
-+	} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
-+		duk_hnativefunction *f = (duk_hnativefunction *) h;
-+		DUK_UNREF(f);
-+		/* Currently nothing to free */
-+	} else if (DUK_HOBJECT_IS_THREAD(h)) {
-+		duk_hthread *t = (duk_hthread *) h;
-+		DUK_FREE(heap, t->valstack);
-+		DUK_FREE(heap, t->callstack);
-+		DUK_FREE(heap, t->catchstack);
-+		/* Don't free h->resumer because it exists in the heap.
-+		 * Callstack entries also contain function pointers which
-+		 * are not freed for the same reason.
-+		 */
-+
-+		/* XXX: with 'caller' property the callstack would need
-+		 * to be unwound to update the 'caller' properties of
-+		 * functions in the callstack.
-+		 */
-+	}
-+}
-+
-+DUK_INTERNAL void duk_free_hbuffer_inner(duk_heap *heap, duk_hbuffer *h) {
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(h != NULL);
-+
-+	if (DUK_HBUFFER_HAS_DYNAMIC(h)) {
-+		duk_hbuffer_dynamic *g = (duk_hbuffer_dynamic *) h;
-+		DUK_DDD(DUK_DDDPRINT("free dynamic buffer %p", (void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g)));
-+		DUK_FREE(heap, DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, g));
-+	}
-+}
-+
-+DUK_INTERNAL void duk_free_hstring_inner(duk_heap *heap, duk_hstring *h) {
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(h != NULL);
-+
-+	DUK_UNREF(heap);
-+	DUK_UNREF(h);
-+
-+#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_FREE)
-+	if (DUK_HSTRING_HAS_EXTDATA(h)) {
-+		DUK_DDD(DUK_DDDPRINT("free extstr: hstring %!O, extdata: %p",
-+		                     h, DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h)));
-+		DUK_USE_EXTSTR_FREE(heap->heap_udata, (const void *) DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) h));
-+	}
-+#endif
-+}
-+
-+DUK_INTERNAL void duk_heap_free_heaphdr_raw(duk_heap *heap, duk_heaphdr *hdr) {
-+	DUK_ASSERT(heap);
-+	DUK_ASSERT(hdr);
-+
-+	DUK_DDD(DUK_DDDPRINT("free heaphdr %p, htype %ld", (void *) hdr, (long) DUK_HEAPHDR_GET_TYPE(hdr)));
-+
-+	switch ((int) DUK_HEAPHDR_GET_TYPE(hdr)) {
-+	case DUK_HTYPE_STRING:
-+		duk_free_hstring_inner(heap, (duk_hstring *) hdr);
-+		break;
-+	case DUK_HTYPE_OBJECT:
-+		duk_free_hobject_inner(heap, (duk_hobject *) hdr);
-+		break;
-+	case DUK_HTYPE_BUFFER:
-+		duk_free_hbuffer_inner(heap, (duk_hbuffer *) hdr);
-+		break;
-+	default:
-+		DUK_UNREACHABLE();
-+	}
-+
-+	DUK_FREE(heap, hdr);
-+}
-+
-+/*
-+ *  Free the heap.
-+ *
-+ *  Frees heap-related non-heap-tracked allocations such as the
-+ *  string intern table; then frees the heap allocated objects;
-+ *  and finally frees the heap structure itself.  Reference counts
-+ *  and GC markers are ignored (and not updated) in this process,
-+ *  and finalizers won't be called.
-+ *
-+ *  The heap pointer and heap object pointers must not be used
-+ *  after this call.
-+ */
-+
-+DUK_LOCAL void duk__free_allocated(duk_heap *heap) {
-+	duk_heaphdr *curr;
-+	duk_heaphdr *next;
-+
-+	curr = heap->heap_allocated;
-+	while (curr) {
-+		/* We don't log or warn about freeing zero refcount objects
-+		 * because they may happen with finalizer processing.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("FINALFREE (allocated): %!iO",
-+		                     (duk_heaphdr *) curr));
-+		next = DUK_HEAPHDR_GET_NEXT(heap, curr);
-+		duk_heap_free_heaphdr_raw(heap, curr);
-+		curr = next;
-+	}
-+}
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+DUK_LOCAL void duk__free_refzero_list(duk_heap *heap) {
-+	duk_heaphdr *curr;
-+	duk_heaphdr *next;
-+
-+	curr = heap->refzero_list;
-+	while (curr) {
-+		DUK_DDD(DUK_DDDPRINT("FINALFREE (refzero_list): %!iO",
-+		                     (duk_heaphdr *) curr));
-+		next = DUK_HEAPHDR_GET_NEXT(heap, curr);
-+		duk_heap_free_heaphdr_raw(heap, curr);
-+		curr = next;
-+	}
-+}
-+#endif
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+DUK_LOCAL void duk__free_markandsweep_finalize_list(duk_heap *heap) {
-+	duk_heaphdr *curr;
-+	duk_heaphdr *next;
-+
-+	curr = heap->finalize_list;
-+	while (curr) {
-+		DUK_DDD(DUK_DDDPRINT("FINALFREE (finalize_list): %!iO",
-+		                     (duk_heaphdr *) curr));
-+		next = DUK_HEAPHDR_GET_NEXT(heap, curr);
-+		duk_heap_free_heaphdr_raw(heap, curr);
-+		curr = next;
-+	}
-+}
-+#endif
-+
-+DUK_LOCAL void duk__free_stringtable(duk_heap *heap) {
-+	/* strings are only tracked by stringtable */
-+	duk_heap_free_strtab(heap);
-+}
-+
-+DUK_LOCAL void duk__free_run_finalizers(duk_heap *heap) {
-+	duk_hthread *thr;
-+	duk_heaphdr *curr;
-+#ifdef DUK_USE_DEBUG
-+	duk_size_t count_obj = 0;
-+#endif
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(heap->heap_thread != NULL);
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	DUK_ASSERT(heap->refzero_list == NULL);  /* refzero not running -> must be empty */
-+#endif
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	DUK_ASSERT(heap->finalize_list == NULL);  /* mark-and-sweep not running -> must be empty */
-+#endif
-+
-+	/* XXX: here again finalizer thread is the heap_thread which needs
-+	 * to be coordinated with finalizer thread fixes.
-+	 */
-+	thr = heap->heap_thread;
-+	DUK_ASSERT(thr != NULL);
-+
-+	curr = heap->heap_allocated;
-+	while (curr) {
-+		if (DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT) {
-+			/* Only objects in heap_allocated may have finalizers.  Check that
-+			 * the object itself has a _Finalizer property so that we don't
-+			 * execute finalizers for e.g. Proxy objects.
-+			 */
-+			DUK_ASSERT(thr != NULL);
-+			DUK_ASSERT(curr != NULL);
-+
-+			if (duk_hobject_hasprop_raw(thr, (duk_hobject *) curr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) {
-+				duk_hobject_run_finalizer(thr, (duk_hobject *) curr);
-+			}
-+#ifdef DUK_USE_DEBUG
-+			count_obj++;
-+#endif
-+		}
-+		curr = DUK_HEAPHDR_GET_NEXT(heap, curr);
-+	}
-+
-+	/* Note: count includes all objects, not only those with an actual finalizer. */
-+#ifdef DUK_USE_DEBUG
-+	DUK_D(DUK_DPRINT("checked %ld objects for finalizers before freeing heap", (long) count_obj));
-+#endif
-+}
-+
-+DUK_INTERNAL void duk_heap_free(duk_heap *heap) {
-+	DUK_D(DUK_DPRINT("free heap: %p", (void *) heap));
-+
-+#if defined(DUK_USE_DEBUG)
-+	duk_heap_dump_strtab(heap);
-+#endif
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	/* Detach a debugger if attached (can be called multiple times)
-+	 * safely.
-+	 */
-+	duk_debug_do_detach(heap);
-+#endif
-+
-+	/* Execute finalizers before freeing the heap, even for reachable
-+	 * objects, and regardless of whether or not mark-and-sweep is
-+	 * enabled.  This gives finalizers the chance to free any native
-+	 * resources like file handles, allocations made outside Duktape,
-+	 * etc.
-+	 *
-+	 * XXX: this perhaps requires an execution time limit.
-+	 */
-+	DUK_D(DUK_DPRINT("execute finalizers before freeing heap"));
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	/* run mark-and-sweep a few times just in case (unreachable
-+	 * object finalizers run already here)
-+	 */
-+	duk_heap_mark_and_sweep(heap, 0);
-+	duk_heap_mark_and_sweep(heap, 0);
-+#endif
-+	duk__free_run_finalizers(heap);
-+
-+	/* Note: heap->heap_thread, heap->curr_thread, heap->heap_object,
-+	 * and heap->log_buffer are on the heap allocated list.
-+	 */
-+
-+	DUK_D(DUK_DPRINT("freeing heap objects of heap: %p", (void *) heap));
-+	duk__free_allocated(heap);
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	DUK_D(DUK_DPRINT("freeing refzero list of heap: %p", (void *) heap));
-+	duk__free_refzero_list(heap);
-+#endif
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	DUK_D(DUK_DPRINT("freeing mark-and-sweep finalize list of heap: %p", (void *) heap));
-+	duk__free_markandsweep_finalize_list(heap);
-+#endif
-+
-+	DUK_D(DUK_DPRINT("freeing string table of heap: %p", (void *) heap));
-+	duk__free_stringtable(heap);
-+
-+	DUK_D(DUK_DPRINT("freeing heap structure: %p", (void *) heap));
-+	heap->free_func(heap->heap_udata, heap);
-+}
-+
-+/*
-+ *  Allocate a heap.
-+ *
-+ *  String table is initialized with built-in strings from genstrings.py.
-+ */
-+
-+/* intern built-in strings from precooked data (genstrings.py) */
-+DUK_LOCAL duk_bool_t duk__init_heap_strings(duk_heap *heap) {
-+	duk_bitdecoder_ctx bd_ctx;
-+	duk_bitdecoder_ctx *bd = &bd_ctx;  /* convenience */
-+	duk_small_uint_t i, j;
-+
-+	DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
-+	bd->data = (const duk_uint8_t *) duk_strings_data;
-+	bd->length = (duk_size_t) DUK_STRDATA_DATA_LENGTH;
-+
-+	for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
-+		duk_uint8_t tmp[DUK_STRDATA_MAX_STRLEN];
-+		duk_hstring *h;
-+		duk_small_uint_t len;
-+		duk_small_uint_t mode;
-+		duk_small_uint_t t;
-+
-+		len = duk_bd_decode(bd, 5);
-+		mode = 32;  /* 0 = uppercase, 32 = lowercase (= 'a' - 'A') */
-+		for (j = 0; j < len; j++) {
-+			t = duk_bd_decode(bd, 5);
-+			if (t < DUK__BITPACK_LETTER_LIMIT) {
-+				t = t + DUK_ASC_UC_A + mode;
-+			} else if (t == DUK__BITPACK_UNDERSCORE) {
-+				t = DUK_ASC_UNDERSCORE;
-+			} else if (t == DUK__BITPACK_FF) {
-+				/* Internal keys are prefixed with 0xFF in the stringtable
-+				 * (which makes them invalid UTF-8 on purpose).
-+				 */
-+				t = 0xff;
-+			} else if (t == DUK__BITPACK_SWITCH1) {
-+				t = duk_bd_decode(bd, 5);
-+				DUK_ASSERT_DISABLE(t >= 0);  /* unsigned */
-+				DUK_ASSERT(t <= 25);
-+				t = t + DUK_ASC_UC_A + (mode ^ 32);
-+			} else if (t == DUK__BITPACK_SWITCH) {
-+				mode = mode ^ 32;
-+				t = duk_bd_decode(bd, 5);
-+				DUK_ASSERT_DISABLE(t >= 0);
-+				DUK_ASSERT(t <= 25);
-+				t = t + DUK_ASC_UC_A + mode;
-+			} else if (t == DUK__BITPACK_SEVENBIT) {
-+				t = duk_bd_decode(bd, 7);
-+			}
-+			tmp[j] = (duk_uint8_t) t;
-+		}
-+
-+		/* No need to length check string: it will never exceed even
-+		 * the 16-bit length maximum.
-+		 */
-+		DUK_ASSERT(len <= 0xffffUL);
-+		DUK_DDD(DUK_DDDPRINT("intern built-in string %ld", (long) i));
-+		h = duk_heap_string_intern(heap, tmp, len);
-+		if (!h) {
-+			goto error;
-+		}
-+
-+		/* Special flags checks.  Since these strings are always
-+		 * reachable and a string cannot appear twice in the string
-+		 * table, there's no need to check/set these flags elsewhere.
-+		 * The 'internal' flag is set by string intern code.
-+		 */
-+		if (i == DUK_STRIDX_EVAL || i == DUK_STRIDX_LC_ARGUMENTS) {
-+			DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(h);
-+		}
-+		if (i >= DUK_STRIDX_START_RESERVED && i < DUK_STRIDX_END_RESERVED) {
-+			DUK_HSTRING_SET_RESERVED_WORD(h);
-+			if (i >= DUK_STRIDX_START_STRICT_RESERVED) {
-+				DUK_HSTRING_SET_STRICT_RESERVED_WORD(h);
-+			}
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("interned: %!O", (duk_heaphdr *) h));
-+
-+		/* XXX: The incref macro takes a thread pointer but doesn't
-+		 * use it right now.
-+		 */
-+		DUK_HSTRING_INCREF(_never_referenced_, h);
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+		heap->strs16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-+#else
-+		heap->strs[i] = h;
-+#endif
-+	}
-+
-+	return 1;
-+
-+ error:
-+	return 0;
-+}
-+
-+DUK_LOCAL duk_bool_t duk__init_heap_thread(duk_heap *heap) {
-+	duk_hthread *thr;
-+
-+	DUK_DD(DUK_DDPRINT("heap init: alloc heap thread"));
-+	thr = duk_hthread_alloc(heap,
-+	                        DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                        DUK_HOBJECT_FLAG_THREAD |
-+	                        DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_THREAD));
-+	if (!thr) {
-+		DUK_D(DUK_DPRINT("failed to alloc heap_thread"));
-+		return 0;
-+	}
-+	thr->state = DUK_HTHREAD_STATE_INACTIVE;
-+#if defined(DUK_USE_HEAPPTR16)
-+	thr->strs16 = heap->strs16;
-+#else
-+	thr->strs = heap->strs;
-+#endif
-+
-+	heap->heap_thread = thr;
-+	DUK_HTHREAD_INCREF(thr, thr);  /* Note: first argument not really used */
-+
-+	/* 'thr' is now reachable */
-+
-+	if (!duk_hthread_init_stacks(heap, thr)) {
-+		return 0;
-+	}
-+
-+	/* XXX: this may now fail, and is not handled correctly */
-+	duk_hthread_create_builtin_objects(thr);
-+
-+	/* default prototype (Note: 'thr' must be reachable) */
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, (duk_hobject *) thr, thr->builtins[DUK_BIDX_THREAD_PROTOTYPE]);
-+
-+	return 1;
-+}
-+
-+#ifdef DUK_USE_DEBUG
-+#define DUK__DUMPSZ(t)  do { \
-+		DUK_D(DUK_DPRINT("" #t "=%ld", (long) sizeof(t))); \
-+	} while (0)
-+
-+/* These is not 100% because format would need to be non-portable "long long".
-+ * Also print out as doubles to catch cases where the "long" type is not wide
-+ * enough; the limits will then not be printed accurately but the magnitude
-+ * will be correct.
-+ */
-+#define DUK__DUMPLM_SIGNED_RAW(t,a,b)  do { \
-+		DUK_D(DUK_DPRINT(t "=[%ld,%ld]=[%lf,%lf]", \
-+		                 (long) (a), (long) (b), \
-+		                 (double) (a), (double) (b))); \
-+	} while(0)
-+#define DUK__DUMPLM_UNSIGNED_RAW(t,a,b)  do { \
-+		DUK_D(DUK_DPRINT(t "=[%lu,%lu]=[%lf,%lf]", \
-+		                 (unsigned long) (a), (unsigned long) (b), \
-+		                 (double) (a), (double) (b))); \
-+	} while(0)
-+#define DUK__DUMPLM_SIGNED(t)  do { \
-+		DUK__DUMPLM_SIGNED_RAW("DUK_" #t "_{MIN,MAX}", DUK_##t##_MIN, DUK_##t##_MAX); \
-+	} while(0)
-+#define DUK__DUMPLM_UNSIGNED(t)  do { \
-+		DUK__DUMPLM_UNSIGNED_RAW("DUK_" #t "_{MIN,MAX}", DUK_##t##_MIN, DUK_##t##_MAX); \
-+	} while(0)
-+
-+DUK_LOCAL void duk__dump_type_sizes(void) {
-+	DUK_D(DUK_DPRINT("sizeof()"));
-+
-+	/* basic platform types */
-+	DUK__DUMPSZ(char);
-+	DUK__DUMPSZ(short);
-+	DUK__DUMPSZ(int);
-+	DUK__DUMPSZ(long);
-+	DUK__DUMPSZ(double);
-+	DUK__DUMPSZ(void *);
-+	DUK__DUMPSZ(size_t);
-+
-+	/* basic types from duk_features.h */
-+	DUK__DUMPSZ(duk_uint8_t);
-+	DUK__DUMPSZ(duk_int8_t);
-+	DUK__DUMPSZ(duk_uint16_t);
-+	DUK__DUMPSZ(duk_int16_t);
-+	DUK__DUMPSZ(duk_uint32_t);
-+	DUK__DUMPSZ(duk_int32_t);
-+	DUK__DUMPSZ(duk_uint64_t);
-+	DUK__DUMPSZ(duk_int64_t);
-+	DUK__DUMPSZ(duk_uint_least8_t);
-+	DUK__DUMPSZ(duk_int_least8_t);
-+	DUK__DUMPSZ(duk_uint_least16_t);
-+	DUK__DUMPSZ(duk_int_least16_t);
-+	DUK__DUMPSZ(duk_uint_least32_t);
-+	DUK__DUMPSZ(duk_int_least32_t);
-+#if defined(DUK_USE_64BIT_OPS)
-+	DUK__DUMPSZ(duk_uint_least64_t);
-+	DUK__DUMPSZ(duk_int_least64_t);
-+#endif
-+	DUK__DUMPSZ(duk_uint_fast8_t);
-+	DUK__DUMPSZ(duk_int_fast8_t);
-+	DUK__DUMPSZ(duk_uint_fast16_t);
-+	DUK__DUMPSZ(duk_int_fast16_t);
-+	DUK__DUMPSZ(duk_uint_fast32_t);
-+	DUK__DUMPSZ(duk_int_fast32_t);
-+#if defined(DUK_USE_64BIT_OPS)
-+	DUK__DUMPSZ(duk_uint_fast64_t);
-+	DUK__DUMPSZ(duk_int_fast64_t);
-+#endif
-+	DUK__DUMPSZ(duk_uintptr_t);
-+	DUK__DUMPSZ(duk_intptr_t);
-+	DUK__DUMPSZ(duk_uintmax_t);
-+	DUK__DUMPSZ(duk_intmax_t);
-+	DUK__DUMPSZ(duk_double_t);
-+
-+	/* important chosen base types */
-+	DUK__DUMPSZ(duk_int_t);
-+	DUK__DUMPSZ(duk_uint_t);
-+	DUK__DUMPSZ(duk_int_fast_t);
-+	DUK__DUMPSZ(duk_uint_fast_t);
-+	DUK__DUMPSZ(duk_small_int_t);
-+	DUK__DUMPSZ(duk_small_uint_t);
-+	DUK__DUMPSZ(duk_small_int_fast_t);
-+	DUK__DUMPSZ(duk_small_uint_fast_t);
-+
-+	/* some derived types */
-+	DUK__DUMPSZ(duk_codepoint_t);
-+	DUK__DUMPSZ(duk_ucodepoint_t);
-+	DUK__DUMPSZ(duk_idx_t);
-+	DUK__DUMPSZ(duk_errcode_t);
-+	DUK__DUMPSZ(duk_uarridx_t);
-+
-+	/* tval */
-+	DUK__DUMPSZ(duk_double_union);
-+	DUK__DUMPSZ(duk_tval);
-+
-+	/* structs from duk_forwdecl.h */
-+	DUK__DUMPSZ(duk_jmpbuf);
-+	DUK__DUMPSZ(duk_heaphdr);
-+	DUK__DUMPSZ(duk_heaphdr_string);
-+	DUK__DUMPSZ(duk_hstring);
-+	DUK__DUMPSZ(duk_hstring_external);
-+	DUK__DUMPSZ(duk_hobject);
-+	DUK__DUMPSZ(duk_hcompiledfunction);
-+	DUK__DUMPSZ(duk_hnativefunction);
-+	DUK__DUMPSZ(duk_hthread);
-+	DUK__DUMPSZ(duk_hbuffer);
-+	DUK__DUMPSZ(duk_hbuffer_fixed);
-+	DUK__DUMPSZ(duk_hbuffer_dynamic);
-+	DUK__DUMPSZ(duk_propaccessor);
-+	DUK__DUMPSZ(duk_propvalue);
-+	DUK__DUMPSZ(duk_propdesc);
-+	DUK__DUMPSZ(duk_heap);
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	DUK__DUMPSZ(duk_strtab_entry);
-+#endif
-+	DUK__DUMPSZ(duk_activation);
-+	DUK__DUMPSZ(duk_catcher);
-+	DUK__DUMPSZ(duk_strcache);
-+	DUK__DUMPSZ(duk_ljstate);
-+	DUK__DUMPSZ(duk_fixedbuffer);
-+	DUK__DUMPSZ(duk_bitdecoder_ctx);
-+	DUK__DUMPSZ(duk_bitencoder_ctx);
-+	DUK__DUMPSZ(duk_token);
-+	DUK__DUMPSZ(duk_re_token);
-+	DUK__DUMPSZ(duk_lexer_point);
-+	DUK__DUMPSZ(duk_lexer_ctx);
-+	DUK__DUMPSZ(duk_compiler_instr);
-+	DUK__DUMPSZ(duk_compiler_func);
-+	DUK__DUMPSZ(duk_compiler_ctx);
-+	DUK__DUMPSZ(duk_re_matcher_ctx);
-+	DUK__DUMPSZ(duk_re_compiler_ctx);
-+}
-+DUK_LOCAL void duk__dump_type_limits(void) {
-+	DUK_D(DUK_DPRINT("limits"));
-+
-+	/* basic types */
-+	DUK__DUMPLM_SIGNED(INT8);
-+	DUK__DUMPLM_UNSIGNED(UINT8);
-+	DUK__DUMPLM_SIGNED(INT_FAST8);
-+	DUK__DUMPLM_UNSIGNED(UINT_FAST8);
-+	DUK__DUMPLM_SIGNED(INT_LEAST8);
-+	DUK__DUMPLM_UNSIGNED(UINT_LEAST8);
-+	DUK__DUMPLM_SIGNED(INT16);
-+	DUK__DUMPLM_UNSIGNED(UINT16);
-+	DUK__DUMPLM_SIGNED(INT_FAST16);
-+	DUK__DUMPLM_UNSIGNED(UINT_FAST16);
-+	DUK__DUMPLM_SIGNED(INT_LEAST16);
-+	DUK__DUMPLM_UNSIGNED(UINT_LEAST16);
-+	DUK__DUMPLM_SIGNED(INT32);
-+	DUK__DUMPLM_UNSIGNED(UINT32);
-+	DUK__DUMPLM_SIGNED(INT_FAST32);
-+	DUK__DUMPLM_UNSIGNED(UINT_FAST32);
-+	DUK__DUMPLM_SIGNED(INT_LEAST32);
-+	DUK__DUMPLM_UNSIGNED(UINT_LEAST32);
-+#if defined(DUK_USE_64BIT_OPS)
-+	DUK__DUMPLM_SIGNED(INT64);
-+	DUK__DUMPLM_UNSIGNED(UINT64);
-+	DUK__DUMPLM_SIGNED(INT_FAST64);
-+	DUK__DUMPLM_UNSIGNED(UINT_FAST64);
-+	DUK__DUMPLM_SIGNED(INT_LEAST64);
-+	DUK__DUMPLM_UNSIGNED(UINT_LEAST64);
-+#endif
-+	DUK__DUMPLM_SIGNED(INTPTR);
-+	DUK__DUMPLM_UNSIGNED(UINTPTR);
-+	DUK__DUMPLM_SIGNED(INTMAX);
-+	DUK__DUMPLM_UNSIGNED(UINTMAX);
-+
-+	/* derived types */
-+	DUK__DUMPLM_SIGNED(INT);
-+	DUK__DUMPLM_UNSIGNED(UINT);
-+	DUK__DUMPLM_SIGNED(INT_FAST);
-+	DUK__DUMPLM_UNSIGNED(UINT_FAST);
-+	DUK__DUMPLM_SIGNED(SMALL_INT);
-+	DUK__DUMPLM_UNSIGNED(SMALL_UINT);
-+	DUK__DUMPLM_SIGNED(SMALL_INT_FAST);
-+	DUK__DUMPLM_UNSIGNED(SMALL_UINT_FAST);
-+}
-+#undef DUK__DUMPSZ
-+#undef DUK__DUMPLM_SIGNED_RAW
-+#undef DUK__DUMPLM_UNSIGNED_RAW
-+#undef DUK__DUMPLM_SIGNED
-+#undef DUK__DUMPLM_UNSIGNED
-+
-+DUK_LOCAL void duk__dump_misc_options(void) {
-+	DUK_D(DUK_DPRINT("DUK_VERSION: %ld", (long) DUK_VERSION));
-+	DUK_D(DUK_DPRINT("DUK_GIT_DESCRIBE: %s", DUK_GIT_DESCRIBE));
-+#if defined(DUK_USE_PACKED_TVAL)
-+	DUK_D(DUK_DPRINT("DUK_USE_PACKED_TVAL: yes"));
-+#else
-+	DUK_D(DUK_DPRINT("DUK_USE_PACKED_TVAL: no"));
-+#endif
-+#if defined(DUK_USE_INTEGER_LE)
-+	DUK_D(DUK_DPRINT("Integer endianness: little"));
-+#elif defined(DUK_USE_INTEGER_ME)
-+	DUK_D(DUK_DPRINT("Integer endianness: mixed"));
-+#elif defined(DUK_USE_INTEGER_BE)
-+	DUK_D(DUK_DPRINT("Integer endianness: big"));
-+#else
-+	DUK_D(DUK_DPRINT("Integer endianness: ???"));
-+#endif
-+#if defined(DUK_USE_DOUBLE_LE)
-+	DUK_D(DUK_DPRINT("IEEE double endianness: little"));
-+#elif defined(DUK_USE_DOUBLE_ME)
-+	DUK_D(DUK_DPRINT("IEEE double endianness: mixed"));
-+#elif defined(DUK_USE_DOUBLE_BE)
-+	DUK_D(DUK_DPRINT("IEEE double endianness: big"));
-+#else
-+	DUK_D(DUK_DPRINT("IEEE double endianness: ???"));
-+#endif
-+}
-+#endif  /* DUK_USE_DEBUG */
-+
-+DUK_INTERNAL
-+duk_heap *duk_heap_alloc(duk_alloc_function alloc_func,
-+                         duk_realloc_function realloc_func,
-+                         duk_free_function free_func,
-+                         void *heap_udata,
-+                         duk_fatal_function fatal_func) {
-+	duk_heap *res = NULL;
-+
-+	DUK_D(DUK_DPRINT("allocate heap"));
-+
-+	/*
-+	 *  Debug dump type sizes
-+	 */
-+
-+#ifdef DUK_USE_DEBUG
-+	duk__dump_misc_options();
-+	duk__dump_type_sizes();
-+	duk__dump_type_limits();
-+#endif
-+
-+	/*
-+	 *  If selftests enabled, run them as early as possible
-+	 */
-+#ifdef DUK_USE_SELF_TESTS
-+	DUK_D(DUK_DPRINT("running self tests"));
-+	duk_selftest_run_tests();
-+	DUK_D(DUK_DPRINT("self tests passed"));
-+#endif
-+
-+#ifdef DUK_USE_COMPUTED_NAN
-+	do {
-+		/* Workaround for some exotic platforms where NAN is missing
-+		 * and the expression (0.0 / 0.0) does NOT result in a NaN.
-+		 * Such platforms use the global 'duk_computed_nan' which must
-+		 * be initialized at runtime.  Use 'volatile' to ensure that
-+		 * the compiler will actually do the computation and not try
-+		 * to do constant folding which might result in the original
-+		 * problem.
-+		 */
-+		volatile double dbl1 = 0.0;
-+		volatile double dbl2 = 0.0;
-+		duk_computed_nan = dbl1 / dbl2;
-+	} while (0);
-+#endif
-+
-+	/*
-+	 *  Computed values (e.g. INFINITY)
-+	 */
-+
-+#ifdef DUK_USE_COMPUTED_INFINITY
-+	do {
-+		/* Similar workaround for INFINITY. */
-+		volatile double dbl1 = 1.0;
-+		volatile double dbl2 = 0.0;
-+		duk_computed_infinity = dbl1 / dbl2;
-+	} while (0);
-+#endif
-+
-+	/*
-+	 *  Allocate heap struct
-+	 *
-+	 *  Use a raw call, all macros expect the heap to be initialized
-+	 */
-+
-+	res = (duk_heap *) alloc_func(heap_udata, sizeof(duk_heap));
-+	if (!res) {
-+		goto error;
-+	}
-+
-+	/*
-+	 *  Zero the struct, and start initializing roughly in order
-+	 */
-+
-+	DUK_MEMZERO(res, sizeof(*res));
-+
-+	/* explicit NULL inits */
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	res->heap_udata = NULL;
-+	res->heap_allocated = NULL;
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	res->refzero_list = NULL;
-+	res->refzero_list_tail = NULL;
-+#endif
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	res->finalize_list = NULL;
-+#endif
-+	res->heap_thread = NULL;
-+	res->curr_thread = NULL;
-+	res->heap_object = NULL;
-+	res->log_buffer = NULL;
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	/* nothing to NULL */
-+#elif defined(DUK_USE_STRTAB_PROBE)
-+#if defined(DUK_USE_HEAPPTR16)
-+	res->strtable16 = (duk_uint16_t *) NULL;
-+#else
-+	res->strtable = (duk_hstring **) NULL;
-+#endif
-+#endif
-+#if defined(DUK_USE_HEAPPTR16)
-+/* res->strs16[] is zeroed and zero decodes to NULL, so no NULL inits. */
-+#else
-+	{
-+		duk_small_uint_t i;
-+	        for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
-+			res->strs[i] = NULL;
-+	        }
-+	}
-+#endif
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	res->dbg_read_cb = NULL;
-+	res->dbg_write_cb = NULL;
-+	res->dbg_peek_cb = NULL;
-+	res->dbg_read_flush_cb = NULL;
-+	res->dbg_write_flush_cb = NULL;
-+	res->dbg_udata = NULL;
-+	res->dbg_step_thread = NULL;
-+#endif
-+#endif  /* DUK_USE_EXPLICIT_NULL_INIT */
-+
-+	res->alloc_func = alloc_func;
-+	res->realloc_func = realloc_func;
-+	res->free_func = free_func;
-+	res->heap_udata = heap_udata;
-+	res->fatal_func = fatal_func;
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+	/* XXX: zero assumption */
-+	res->heapptr_null16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) NULL);
-+	res->heapptr_deleted16 = DUK_USE_HEAPPTR_ENC16(res->heap_udata, (void *) DUK_STRTAB_DELETED_MARKER(res));
-+#endif
-+
-+	/* res->mark_and_sweep_trigger_counter == 0 -> now causes immediate GC; which is OK */
-+
-+	res->call_recursion_depth = 0;
-+	res->call_recursion_limit = DUK_HEAP_DEFAULT_CALL_RECURSION_LIMIT;
-+
-+	/* XXX: use the pointer as a seed for now: mix in time at least */
-+
-+	/* The casts through duk_intr_pt is to avoid the following GCC warning:
-+	 *
-+	 *   warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
-+	 *
-+	 * This still generates a /Wp64 warning on VS2010 when compiling for x86.
-+	 */
-+	res->hash_seed = (duk_uint32_t) (duk_intptr_t) res;
-+	res->rnd_state = (duk_uint32_t) (duk_intptr_t) res;
-+
-+#ifdef DUK_USE_INTERRUPT_COUNTER
-+	/* zero value causes an interrupt before executing first instruction */
-+	DUK_ASSERT(res->interrupt_counter == 0);
-+	DUK_ASSERT(res->interrupt_init == 0);
-+#endif
-+
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	res->lj.jmpbuf_ptr = NULL;
-+#endif
-+	DUK_ASSERT(res->lj.type == DUK_LJ_TYPE_UNKNOWN);  /* zero */
-+
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value1);
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(&res->lj.value2);
-+
-+#if (DUK_STRTAB_INITIAL_SIZE < DUK_UTIL_MIN_HASH_PRIME)
-+#error initial heap stringtable size is defined incorrectly
-+#endif
-+
-+	/*
-+	 *  Init stringtable: fixed variant
-+	 */
-+
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	DUK_MEMZERO(res->strtable, sizeof(duk_strtab_entry) * DUK_STRTAB_CHAIN_SIZE);
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	{
-+		duk_small_uint_t i;
-+	        for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+			res->strtable[i].u.str16 = res->heapptr_null16;
-+#else
-+			res->strtable[i].u.str = NULL;
-+#endif
-+	        }
-+	}
-+#endif  /* DUK_USE_EXPLICIT_NULL_INIT */
-+#endif  /* DUK_USE_STRTAB_CHAIN */
-+
-+	/*
-+	 *  Init stringtable: probe variant
-+	 */
-+
-+#if defined(DUK_USE_STRTAB_PROBE)
-+#if defined(DUK_USE_HEAPPTR16)
-+	res->strtable16 = (duk_uint16_t *) alloc_func(heap_udata, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE);
-+	if (!res->strtable16) {
-+		goto error;
-+	}
-+#else  /* DUK_USE_HEAPPTR16 */
-+	res->strtable = (duk_hstring **) alloc_func(heap_udata, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
-+	if (!res->strtable) {
-+		goto error;
-+	}
-+#endif  /* DUK_USE_HEAPPTR16 */
-+	res->st_size = DUK_STRTAB_INITIAL_SIZE;
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	{
-+		duk_small_uint_t i;
-+		DUK_ASSERT(res->st_size == DUK_STRTAB_INITIAL_SIZE);
-+	        for (i = 0; i < DUK_STRTAB_INITIAL_SIZE; i++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+			res->strtable16[i] = res->heapptr_null16;
-+#else
-+			res->strtable[i] = NULL;
-+#endif
-+	        }
-+	}
-+#else  /* DUK_USE_EXPLICIT_NULL_INIT */
-+#if defined(DUK_USE_HEAPPTR16)
-+	DUK_MEMZERO(res->strtable16, sizeof(duk_uint16_t) * DUK_STRTAB_INITIAL_SIZE);
-+#else
-+	DUK_MEMZERO(res->strtable, sizeof(duk_hstring *) * DUK_STRTAB_INITIAL_SIZE);
-+#endif
-+#endif  /* DUK_USE_EXPLICIT_NULL_INIT */
-+#endif  /* DUK_USE_STRTAB_PROBE */
-+
-+	/*
-+	 *  Init stringcache
-+	 */
-+
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	{
-+		duk_small_uint_t i;
-+		for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-+			res->strcache[i].h = NULL;
-+		}
-+	}
-+#endif
-+
-+	/* XXX: error handling is incomplete.  It would be cleanest if
-+	 * there was a setjmp catchpoint, so that all init code could
-+	 * freely throw errors.  If that were the case, the return code
-+	 * passing here could be removed.
-+	 */
-+
-+	/*
-+	 *  Init built-in strings
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("HEAP: INIT STRINGS"));
-+	if (!duk__init_heap_strings(res)) {
-+		goto error;
-+	}
-+
-+	/*
-+	 *  Init the heap thread
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP THREAD"));
-+	if (!duk__init_heap_thread(res)) {
-+		goto error;
-+	}
-+
-+	/*
-+	 *  Init the heap object
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("HEAP: INIT HEAP OBJECT"));
-+	DUK_ASSERT(res->heap_thread != NULL);
-+	res->heap_object = duk_hobject_alloc(res, DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                                          DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT));
-+	if (!res->heap_object) {
-+		goto error;
-+	}
-+	DUK_HOBJECT_INCREF(res->heap_thread, res->heap_object);
-+
-+	/*
-+	 *  Init log buffer
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("HEAP: INIT LOG BUFFER"));
-+	res->log_buffer = (duk_hbuffer_dynamic *) duk_hbuffer_alloc(res,
-+	                                                            DUK_BI_LOGGER_SHORT_MSG_LIMIT,
-+	                                                            DUK_BUF_FLAG_DYNAMIC /*flags*/);
-+	if (!res->log_buffer) {
-+		goto error;
-+	}
-+	DUK_HBUFFER_INCREF(res->heap_thread, res->log_buffer);
-+
-+	/*
-+	 *  All done
-+	 */
-+
-+	DUK_D(DUK_DPRINT("allocated heap: %p", (void *) res));
-+	return res;
-+
-+ error:
-+	DUK_D(DUK_DPRINT("heap allocation failed"));
-+
-+	if (res) {
-+		/* assumes that allocated pointers and alloc funcs are valid
-+		 * if res exists
-+		 */
-+		DUK_ASSERT(res->alloc_func != NULL);
-+		DUK_ASSERT(res->realloc_func != NULL);
-+		DUK_ASSERT(res->free_func != NULL);
-+		duk_heap_free(res);
-+	}
-+	return NULL;
-+}
-+#line 1 "duk_heap_hashstring.c"
-+/*
-+ *  String hash computation (interning).
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* constants for duk_hashstring() */
-+#define DUK__STRHASH_SHORTSTRING   4096L
-+#define DUK__STRHASH_MEDIUMSTRING  (256L * 1024L)
-+#define DUK__STRHASH_BLOCKSIZE     256L
-+
-+DUK_INTERNAL duk_uint32_t duk_heap_hashstring(duk_heap *heap, const duk_uint8_t *str, duk_size_t len) {
-+	duk_uint32_t hash;
-+
-+	/*
-+	 *  Sampling long strings by byte skipping (like Lua does) is potentially
-+	 *  a cache problem.  Here we do 'block skipping' instead for long strings:
-+	 *  hash an initial part, and then sample the rest of the string with
-+	 *  reasonably sized chunks.
-+	 *
-+	 *  Skip should depend on length and bound the total time to roughly
-+	 *  logarithmic.
-+	 *
-+	 *  With current values:
-+	 *
-+	 *    1M string => 256 * 241 = 61696 bytes (0.06M) of hashing
-+	 *    1G string => 256 * 16321 = 4178176 bytes (3.98M) of hashing
-+	 *
-+	 *  After an initial part has been hashed, an offset is applied before
-+	 *  starting the sampling.  The initial offset is computed from the
-+	 *  hash of the initial part of the string.  The idea is to avoid the
-+	 *  case that all long strings have certain offset ranges that are never
-+	 *  sampled.
-+	 */
-+
-+	/* note: mixing len into seed improves hashing when skipping */
-+	duk_uint32_t str_seed = heap->hash_seed ^ ((duk_uint32_t) len);
-+
-+	if (len <= DUK__STRHASH_SHORTSTRING) {
-+		hash = duk_util_hashbytes(str, len, str_seed);
-+	} else {
-+		duk_size_t off;
-+		duk_size_t skip;
-+
-+		if (len <= DUK__STRHASH_MEDIUMSTRING) {
-+			skip = (duk_size_t) (16 * DUK__STRHASH_BLOCKSIZE + DUK__STRHASH_BLOCKSIZE);
-+		} else {
-+			skip = (duk_size_t) (256 * DUK__STRHASH_BLOCKSIZE + DUK__STRHASH_BLOCKSIZE);
-+		}
-+
-+		hash = duk_util_hashbytes(str, (duk_size_t) DUK__STRHASH_SHORTSTRING, str_seed);
-+		off = DUK__STRHASH_SHORTSTRING + (skip * (hash % 256)) / 256;
-+
-+		/* XXX: inefficient loop */
-+		while (off < len) {
-+			duk_size_t left = len - off;
-+			duk_size_t now = (duk_size_t) (left > DUK__STRHASH_BLOCKSIZE ? DUK__STRHASH_BLOCKSIZE : left);
-+			hash ^= duk_util_hashbytes(str + off, now, str_seed);
-+			off += skip;
-+		}
-+	}
-+
-+#if defined(DUK_USE_STRHASH16)
-+	/* Truncate to 16 bits here, so that a computed hash can be compared
-+	 * against a hash stored in a 16-bit field.
-+	 */
-+	hash &= 0x0000ffffUL;
-+#endif
-+	return hash;
-+}
-+#line 1 "duk_heap_markandsweep.c"
-+/*
-+ *  Mark-and-sweep garbage collection.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+
-+DUK_LOCAL_DECL void duk__mark_heaphdr(duk_heap *heap, duk_heaphdr *h);
-+DUK_LOCAL_DECL void duk__mark_tval(duk_heap *heap, duk_tval *tv);
-+
-+/*
-+ *  Misc
-+ */
-+
-+/* Select a thread for mark-and-sweep use.
-+ *
-+ * XXX: This needs to change later.
-+ */
-+DUK_LOCAL duk_hthread *duk__get_temp_hthread(duk_heap *heap) {
-+	if (heap->curr_thread) {
-+		return heap->curr_thread;
-+	}
-+	return heap->heap_thread;  /* may be NULL, too */
-+}
-+
-+/*
-+ *  Marking functions for heap types: mark children recursively
-+ */
-+
-+DUK_LOCAL void duk__mark_hstring(duk_heap *heap, duk_hstring *h) {
-+	DUK_UNREF(heap);
-+	DUK_UNREF(h);
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__mark_hstring: %p", (void *) h));
-+	DUK_ASSERT(h);
-+
-+	/* nothing to process */
-+}
-+
-+DUK_LOCAL void duk__mark_hobject(duk_heap *heap, duk_hobject *h) {
-+	duk_uint_fast32_t i;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__mark_hobject: %p", (void *) h));
-+
-+	DUK_ASSERT(h);
-+
-+	/* XXX: use advancing pointers instead of index macros -> faster and smaller? */
-+
-+	for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
-+		duk_hstring *key = DUK_HOBJECT_E_GET_KEY(heap, h, i);
-+		if (!key) {
-+			continue;
-+		}
-+		duk__mark_heaphdr(heap, (duk_heaphdr *) key);
-+		if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, h, i)) {
-+			duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.get);
-+			duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->a.set);
-+		} else {
-+			duk__mark_tval(heap, &DUK_HOBJECT_E_GET_VALUE_PTR(heap, h, i)->v);
-+		}
-+	}
-+
-+	for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
-+		duk__mark_tval(heap, DUK_HOBJECT_A_GET_VALUE_PTR(heap, h, i));
-+	}
-+
-+	/* hash part is a 'weak reference' and does not contribute */
-+
-+	duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(heap, h));
-+
-+	if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
-+		duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
-+		duk_tval *tv, *tv_end;
-+		duk_hobject **funcs, **funcs_end;
-+
-+		/* 'data' is reachable through every compiled function which
-+		 * contains a reference.
-+		 */
-+
-+		duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_HCOMPILEDFUNCTION_GET_DATA(heap, f));
-+
-+		tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(heap, f);
-+		tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(heap, f);
-+		while (tv < tv_end) {
-+			duk__mark_tval(heap, tv);
-+			tv++;
-+		}
-+
-+		funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(heap, f);
-+		funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(heap, f);
-+		while (funcs < funcs_end) {
-+			duk__mark_heaphdr(heap, (duk_heaphdr *) *funcs);
-+			funcs++;
-+		}
-+	} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
-+		duk_hnativefunction *f = (duk_hnativefunction *) h;
-+		DUK_UNREF(f);
-+		/* nothing to mark */
-+	} else if (DUK_HOBJECT_IS_THREAD(h)) {
-+		duk_hthread *t = (duk_hthread *) h;
-+		duk_tval *tv;
-+
-+		tv = t->valstack;
-+		while (tv < t->valstack_end) {
-+			duk__mark_tval(heap, tv);
-+			tv++;
-+		}
-+
-+		for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
-+			duk_activation *act = t->callstack + i;
-+			duk__mark_heaphdr(heap, (duk_heaphdr *) DUK_ACT_GET_FUNC(act));
-+			duk__mark_heaphdr(heap, (duk_heaphdr *) act->var_env);
-+			duk__mark_heaphdr(heap, (duk_heaphdr *) act->lex_env);
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+			duk__mark_heaphdr(heap, (duk_heaphdr *) act->prev_caller);
-+#endif
-+		}
-+
-+#if 0  /* nothing now */
-+		for (i = 0; i < (duk_uint_fast32_t) t->catchstack_top; i++) {
-+			duk_catcher *cat = t->catchstack + i;
-+		}
-+#endif
-+
-+		duk__mark_heaphdr(heap, (duk_heaphdr *) t->resumer);
-+
-+		/* XXX: duk_small_uint_t would be enough for this loop */
-+		for (i = 0; i < DUK_NUM_BUILTINS; i++) {
-+			duk__mark_heaphdr(heap, (duk_heaphdr *) t->builtins[i]);
-+		}
-+	}
-+}
-+
-+/* recursion tracking happens here only */
-+DUK_LOCAL void duk__mark_heaphdr(duk_heap *heap, duk_heaphdr *h) {
-+	DUK_DDD(DUK_DDDPRINT("duk__mark_heaphdr %p, type %ld",
-+	                     (void *) h,
-+	                     (h != NULL ? (long) DUK_HEAPHDR_GET_TYPE(h) : (long) -1)));
-+	if (!h) {
-+		return;
-+	}
-+
-+	if (DUK_HEAPHDR_HAS_REACHABLE(h)) {
-+		DUK_DDD(DUK_DDDPRINT("already marked reachable, skip"));
-+		return;
-+	}
-+	DUK_HEAPHDR_SET_REACHABLE(h);
-+
-+	if (heap->mark_and_sweep_recursion_depth >= DUK_HEAP_MARK_AND_SWEEP_RECURSION_LIMIT) {
-+		/* log this with a normal debug level because this should be relatively rare */
-+		DUK_D(DUK_DPRINT("mark-and-sweep recursion limit reached, marking as temproot: %p", (void *) h));
-+		DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap);
-+		DUK_HEAPHDR_SET_TEMPROOT(h);
-+		return;
-+	}
-+
-+	heap->mark_and_sweep_recursion_depth++;
-+
-+	switch ((int) DUK_HEAPHDR_GET_TYPE(h)) {
-+	case DUK_HTYPE_STRING:
-+		duk__mark_hstring(heap, (duk_hstring *) h);
-+		break;
-+	case DUK_HTYPE_OBJECT:
-+		duk__mark_hobject(heap, (duk_hobject *) h);
-+		break;
-+	case DUK_HTYPE_BUFFER:
-+		/* nothing to mark */
-+		break;
-+	default:
-+		DUK_D(DUK_DPRINT("attempt to mark heaphdr %p with invalid htype %ld", (void *) h, (long) DUK_HEAPHDR_GET_TYPE(h)));
-+		DUK_UNREACHABLE();
-+	}
-+
-+	heap->mark_and_sweep_recursion_depth--;
-+}
-+
-+DUK_LOCAL void duk__mark_tval(duk_heap *heap, duk_tval *tv) {
-+	DUK_DDD(DUK_DDDPRINT("duk__mark_tval %p", (void *) tv));
-+	if (!tv) {
-+		return;
-+	}
-+	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		duk__mark_heaphdr(heap, DUK_TVAL_GET_HEAPHDR(tv));
-+	}
-+}
-+
-+/*
-+ *  Mark the heap.
-+ */
-+
-+DUK_LOCAL void duk__mark_roots_heap(duk_heap *heap) {
-+	duk_small_uint_t i;
-+
-+	DUK_DD(DUK_DDPRINT("duk__mark_roots_heap: %p", (void *) heap));
-+
-+	duk__mark_heaphdr(heap, (duk_heaphdr *) heap->heap_thread);
-+	duk__mark_heaphdr(heap, (duk_heaphdr *) heap->heap_object);
-+	duk__mark_heaphdr(heap, (duk_heaphdr *) heap->log_buffer);
-+
-+	for (i = 0; i < DUK_HEAP_NUM_STRINGS; i++) {
-+		duk_hstring *h = DUK_HEAP_GET_STRING(heap, i);
-+		duk__mark_heaphdr(heap, (duk_heaphdr *) h);
-+	}
-+
-+	duk__mark_tval(heap, &heap->lj.value1);
-+	duk__mark_tval(heap, &heap->lj.value2);
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	for (i = 0; i < heap->dbg_breakpoint_count; i++) {
-+		duk__mark_heaphdr(heap, (duk_heaphdr *) heap->dbg_breakpoints[i].filename);
-+	}
-+#endif
-+}
-+
-+/*
-+ *  Mark refzero_list objects.
-+ *
-+ *  Objects on the refzero_list have no inbound references.  They might have
-+ *  outbound references to objects that we might free, which would invalidate
-+ *  any references held by the refzero objects.  A refzero object might also
-+ *  be rescued by refcount finalization.  Refzero objects are treated as
-+ *  reachability roots to ensure they (or anything they point to) are not
-+ *  freed in mark-and-sweep.
-+ */
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+DUK_LOCAL void duk__mark_refzero_list(duk_heap *heap) {
-+	duk_heaphdr *hdr;
-+
-+	DUK_DD(DUK_DDPRINT("duk__mark_refzero_list: %p", (void *) heap));
-+
-+	hdr = heap->refzero_list;
-+	while (hdr) {
-+		duk__mark_heaphdr(heap, hdr);
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+}
-+#endif
-+
-+/*
-+ *  Mark unreachable, finalizable objects.
-+ *
-+ *  Such objects will be moved aside and their finalizers run later.  They have
-+ *  to be treated as reachability roots for their properties etc to remain
-+ *  allocated.  This marking is only done for unreachable values which would
-+ *  be swept later (refzero_list is thus excluded).
-+ *
-+ *  Objects are first marked FINALIZABLE and only then marked as reachability
-+ *  roots; otherwise circular references might be handled inconsistently.
-+ */
-+
-+DUK_LOCAL void duk__mark_finalizable(duk_heap *heap) {
-+	duk_hthread *thr;
-+	duk_heaphdr *hdr;
-+	duk_size_t count_finalizable = 0;
-+
-+	DUK_DD(DUK_DDPRINT("duk__mark_finalizable: %p", (void *) heap));
-+
-+	thr = duk__get_temp_hthread(heap);
-+	DUK_ASSERT(thr != NULL);
-+
-+	hdr = heap->heap_allocated;
-+	while (hdr) {
-+		/* A finalizer is looked up from the object and up its prototype chain
-+		 * (which allows inherited finalizers).  A prototype loop must not cause
-+		 * an error to be thrown here; duk_hobject_hasprop_raw() will ignore a
-+		 * prototype loop silently and indicate that the property doesn't exist.
-+		 */
-+
-+		if (!DUK_HEAPHDR_HAS_REACHABLE(hdr) &&
-+		    DUK_HEAPHDR_GET_TYPE(hdr) == DUK_HTYPE_OBJECT &&
-+		    !DUK_HEAPHDR_HAS_FINALIZED(hdr) &&
-+		    duk_hobject_hasprop_raw(thr, (duk_hobject *) hdr, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) {
-+
-+			/* heaphdr:
-+			 *  - is not reachable
-+			 *  - is an object
-+			 *  - is not a finalized object
-+			 *  - has a finalizer
-+			 */
-+
-+			DUK_DD(DUK_DDPRINT("unreachable heap object will be "
-+			                   "finalized -> mark as finalizable "
-+			                   "and treat as a reachability root: %p",
-+			                   (void *) hdr));
-+			DUK_HEAPHDR_SET_FINALIZABLE(hdr);
-+			count_finalizable ++;
-+		}
-+
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+
-+	if (count_finalizable == 0) {
-+		return;
-+	}
-+
-+	DUK_DD(DUK_DDPRINT("marked %ld heap objects as finalizable, now mark them reachable",
-+	                   (long) count_finalizable));
-+
-+	hdr = heap->heap_allocated;
-+	while (hdr) {
-+		if (DUK_HEAPHDR_HAS_FINALIZABLE(hdr)) {
-+			duk__mark_heaphdr(heap, hdr);
-+		}
-+
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+
-+	/* Caller will finish the marking process if we hit a recursion limit. */
-+}
-+
-+/*
-+ *  Mark objects on finalize_list.
-+ *
-+ */
-+
-+DUK_LOCAL void duk__mark_finalize_list(duk_heap *heap) {
-+	duk_heaphdr *hdr;
-+#ifdef DUK_USE_DEBUG
-+	duk_size_t count_finalize_list = 0;
-+#endif
-+
-+	DUK_DD(DUK_DDPRINT("duk__mark_finalize_list: %p", (void *) heap));
-+
-+	hdr = heap->finalize_list;
-+	while (hdr) {
-+		duk__mark_heaphdr(heap, hdr);
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+#ifdef DUK_USE_DEBUG
-+		count_finalize_list++;
-+#endif
-+	}
-+
-+#ifdef DUK_USE_DEBUG
-+	if (count_finalize_list > 0) {
-+		DUK_D(DUK_DPRINT("marked %ld objects on the finalize_list as reachable (previous finalizer run skipped)",
-+		                 (long) count_finalize_list));
-+	}
-+#endif
-+}
-+
-+/*
-+ *  Fallback marking handler if recursion limit is reached.
-+ *
-+ *  Iterates 'temproots' until recursion limit is no longer hit.  Note
-+ *  that temproots may reside either in heap allocated list or the
-+ *  refzero work list.  This is a slow scan, but guarantees that we
-+ *  finish with a bounded C stack.
-+ *
-+ *  Note that nodes may have been marked as temproots before this
-+ *  scan begun, OR they may have been marked during the scan (as
-+ *  we process nodes recursively also during the scan).  This is
-+ *  intended behavior.
-+ */
-+
-+#ifdef DUK_USE_DEBUG
-+DUK_LOCAL void duk__handle_temproot(duk_heap *heap, duk_heaphdr *hdr, duk_size_t *count) {
-+#else
-+DUK_LOCAL void duk__handle_temproot(duk_heap *heap, duk_heaphdr *hdr) {
-+#endif
-+	if (!DUK_HEAPHDR_HAS_TEMPROOT(hdr)) {
-+		DUK_DDD(DUK_DDDPRINT("not a temp root: %p", (void *) hdr));
-+		return;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("found a temp root: %p", (void *) hdr));
-+	DUK_HEAPHDR_CLEAR_TEMPROOT(hdr);
-+	DUK_HEAPHDR_CLEAR_REACHABLE(hdr);  /* done so that duk__mark_heaphdr() works correctly */
-+	duk__mark_heaphdr(heap, hdr);
-+
-+#ifdef DUK_USE_DEBUG
-+	(*count)++;
-+#endif
-+}
-+
-+DUK_LOCAL void duk__mark_temproots_by_heap_scan(duk_heap *heap) {
-+	duk_heaphdr *hdr;
-+#ifdef DUK_USE_DEBUG
-+	duk_size_t count;
-+#endif
-+
-+	DUK_DD(DUK_DDPRINT("duk__mark_temproots_by_heap_scan: %p", (void *) heap));
-+
-+	while (DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)) {
-+		DUK_DD(DUK_DDPRINT("recursion limit reached, doing heap scan to continue from temproots"));
-+
-+#ifdef DUK_USE_DEBUG
-+		count = 0;
-+#endif
-+		DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap);
-+
-+		hdr = heap->heap_allocated;
-+		while (hdr) {
-+#ifdef DUK_USE_DEBUG
-+			duk__handle_temproot(heap, hdr, &count);
-+#else
-+			duk__handle_temproot(heap, hdr);
-+#endif
-+			hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+		}
-+
-+		/* must also check refzero_list */
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		hdr = heap->refzero_list;
-+		while (hdr) {
-+#ifdef DUK_USE_DEBUG
-+			duk__handle_temproot(heap, hdr, &count);
-+#else
-+			duk__handle_temproot(heap, hdr);
-+#endif
-+			hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+		}
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+
-+#ifdef DUK_USE_DEBUG
-+		DUK_DD(DUK_DDPRINT("temproot mark heap scan processed %ld temp roots", (long) count));
-+#endif
-+	}
-+}
-+
-+/*
-+ *  Finalize refcounts for heap elements just about to be freed.
-+ *  This must be done for all objects before freeing to avoid any
-+ *  stale pointer dereferences.
-+ *
-+ *  Note that this must deduce the set of objects to be freed
-+ *  identically to duk__sweep_heap().
-+ */
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+DUK_LOCAL void duk__finalize_refcounts(duk_heap *heap) {
-+	duk_hthread *thr;
-+	duk_heaphdr *hdr;
-+
-+	thr = duk__get_temp_hthread(heap);
-+	DUK_ASSERT(thr != NULL);
-+
-+	DUK_DD(DUK_DDPRINT("duk__finalize_refcounts: heap=%p, hthread=%p",
-+	                   (void *) heap, (void *) thr));
-+
-+	hdr = heap->heap_allocated;
-+	while (hdr) {
-+		if (!DUK_HEAPHDR_HAS_REACHABLE(hdr)) {
-+			/*
-+			 *  Unreachable object about to be swept.  Finalize target refcounts
-+			 *  (objects which the unreachable object points to) without doing
-+			 *  refzero processing.  Recursive decrefs are also prevented when
-+			 *  refzero processing is disabled.
-+			 *
-+			 *  Value cannot be a finalizable object, as they have been made
-+			 *  temporarily reachable for this round.
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("unreachable object, refcount finalize before sweeping: %p", (void *) hdr));
-+			duk_heaphdr_refcount_finalize(thr, hdr);
-+		}
-+
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+}
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+
-+/*
-+ *  Clear (reachable) flags of refzero work list.
-+ */
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+DUK_LOCAL void duk__clear_refzero_list_flags(duk_heap *heap) {
-+	duk_heaphdr *hdr;
-+
-+	DUK_DD(DUK_DDPRINT("duk__clear_refzero_list_flags: %p", (void *) heap));
-+
-+	hdr = heap->refzero_list;
-+	while (hdr) {
-+		DUK_HEAPHDR_CLEAR_REACHABLE(hdr);
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(hdr));
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+}
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+
-+/*
-+ *  Clear (reachable) flags of finalize_list
-+ *
-+ *  We could mostly do in the sweep phase when we move objects from the
-+ *  heap into the finalize_list.  However, if a finalizer run is skipped
-+ *  during a mark-and-sweep, the objects on the finalize_list will be marked
-+ *  reachable during the next mark-and-sweep.  Since they're already on the
-+ *  finalize_list, no-one will be clearing their REACHABLE flag so we do it
-+ *  here.  (This now overlaps with the sweep handling in a harmless way.)
-+ */
-+
-+DUK_LOCAL void duk__clear_finalize_list_flags(duk_heap *heap) {
-+	duk_heaphdr *hdr;
-+
-+	DUK_DD(DUK_DDPRINT("duk__clear_finalize_list_flags: %p", (void *) heap));
-+
-+	hdr = heap->finalize_list;
-+	while (hdr) {
-+		DUK_HEAPHDR_CLEAR_REACHABLE(hdr);
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(hdr));
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+}
-+
-+/*
-+ *  Sweep stringtable
-+ */
-+
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+
-+/* XXX: skip count_free w/o debug? */
-+#if defined(DUK_USE_HEAPPTR16)
-+DUK_LOCAL void duk__sweep_string_chain16(duk_heap *heap, duk_uint16_t *slot, duk_size_t *count_keep, duk_size_t *count_free) {
-+	duk_uint16_t h16 = *slot;
-+	duk_hstring *h;
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+
-+	if (h16 == null16) {
-+		/* nop */
-+		return;
-+	}
-+	h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, h16);
-+	DUK_ASSERT(h != NULL);
-+
-+	if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
-+		DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);
-+		(*count_keep)++;
-+	} else {
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+		DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0);
-+#endif
-+		/* deal with weak references first */
-+		duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
-+		*slot = null16;
-+
-+		/* free inner references (these exist e.g. when external
-+		 * strings are enabled)
-+		 */
-+		duk_free_hstring_inner(heap, h);
-+		DUK_FREE(heap, h);
-+		(*count_free)++;
-+	}
-+}
-+#else  /* DUK_USE_HEAPPTR16 */
-+DUK_LOCAL void duk__sweep_string_chain(duk_heap *heap, duk_hstring **slot, duk_size_t *count_keep, duk_size_t *count_free) {
-+	duk_hstring *h = *slot;
-+
-+	if (h == NULL) {
-+		/* nop */
-+		return;
-+	}
-+
-+	if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
-+		DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);
-+		(*count_keep)++;
-+	} else {
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+		DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0);
-+#endif
-+		/* deal with weak references first */
-+		duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
-+		*slot = NULL;
-+
-+		/* free inner references (these exist e.g. when external
-+		 * strings are enabled)
-+		 */
-+		duk_free_hstring_inner(heap, h);
-+		DUK_FREE(heap, h);
-+		(*count_free)++;
-+	}
-+}
-+#endif  /* DUK_USE_HEAPPTR16 */
-+
-+DUK_LOCAL void duk__sweep_stringtable_chain(duk_heap *heap, duk_size_t *out_count_keep) {
-+	duk_strtab_entry *e;
-+	duk_uint_fast32_t i;
-+	duk_size_t count_free = 0;
-+	duk_size_t count_keep = 0;
-+	duk_size_t j, n;
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t *lst;
-+#else
-+	duk_hstring **lst;
-+#endif
-+
-+	DUK_DD(DUK_DDPRINT("duk__sweep_stringtable: %p", (void *) heap));
-+
-+	/* Non-zero refcounts should not happen for unreachable strings,
-+	 * because we refcount finalize all unreachable objects which
-+	 * should have decreased unreachable string refcounts to zero
-+	 * (even for cycles).
-+	 */
-+
-+	for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
-+		e = heap->strtable + i;
-+		if (e->listlen == 0) {
-+#if defined(DUK_USE_HEAPPTR16)
-+			duk__sweep_string_chain16(heap, &e->u.str16, &count_keep, &count_free);
-+#else
-+			duk__sweep_string_chain(heap, &e->u.str, &count_keep, &count_free);
-+#endif
-+		} else {
-+#if defined(DUK_USE_HEAPPTR16)
-+			lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-+#else
-+			lst = e->u.strlist;
-+#endif
-+			for (j = 0, n = e->listlen; j < n; j++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+				duk__sweep_string_chain16(heap, lst + j, &count_keep, &count_free);
-+#else
-+				duk__sweep_string_chain(heap, lst + j, &count_keep, &count_free);
-+#endif
-+			}
-+		}
-+	}
-+
-+	DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %ld freed, %ld kept",
-+	                 (long) count_free, (long) count_keep));
-+	*out_count_keep = count_keep;
-+}
-+#endif  /* DUK_USE_STRTAB_CHAIN */
-+
-+#if defined(DUK_USE_STRTAB_PROBE)
-+DUK_LOCAL void duk__sweep_stringtable_probe(duk_heap *heap, duk_size_t *out_count_keep) {
-+	duk_hstring *h;
-+	duk_uint_fast32_t i;
-+#ifdef DUK_USE_DEBUG
-+	duk_size_t count_free = 0;
-+#endif
-+	duk_size_t count_keep = 0;
-+
-+	DUK_DD(DUK_DDPRINT("duk__sweep_stringtable: %p", (void *) heap));
-+
-+	for (i = 0; i < heap->st_size; i++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+		h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->strtable16[i]);
-+#else
-+		h = heap->strtable[i];
-+#endif
-+		if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
-+			continue;
-+		} else if (DUK_HEAPHDR_HAS_REACHABLE((duk_heaphdr *) h)) {
-+			DUK_HEAPHDR_CLEAR_REACHABLE((duk_heaphdr *) h);
-+			count_keep++;
-+			continue;
-+		}
-+
-+#ifdef DUK_USE_DEBUG
-+		count_free++;
-+#endif
-+
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+		/* Non-zero refcounts should not happen for unreachable strings,
-+		 * because we refcount finalize all unreachable objects which
-+		 * should have decreased unreachable string refcounts to zero
-+		 * (even for cycles).
-+		 */
-+		DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT((duk_heaphdr *) h) == 0);
-+#endif
-+
-+		DUK_DDD(DUK_DDDPRINT("sweep string, not reachable: %p", (void *) h));
-+
-+		/* deal with weak references first */
-+		duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
-+
-+		/* remove the string (mark DELETED), could also call
-+		 * duk_heap_string_remove() but that would be slow and
-+		 * pointless because we already know the slot.
-+		 */
-+#if defined(DUK_USE_HEAPPTR16)
-+		heap->strtable16[i] = heap->heapptr_deleted16;
-+#else
-+		heap->strtable[i] = DUK_STRTAB_DELETED_MARKER(heap);
-+#endif
-+
-+		/* free inner references (these exist e.g. when external
-+		 * strings are enabled)
-+		 */
-+		duk_free_hstring_inner(heap, (duk_hstring *) h);
-+
-+		/* finally free the struct itself */
-+		DUK_FREE(heap, h);
-+	}
-+
-+#ifdef DUK_USE_DEBUG
-+	DUK_D(DUK_DPRINT("mark-and-sweep sweep stringtable: %ld freed, %ld kept",
-+	                 (long) count_free, (long) count_keep));
-+#endif
-+	*out_count_keep = count_keep;
-+}
-+#endif  /* DUK_USE_STRTAB_PROBE */
-+
-+/*
-+ *  Sweep heap
-+ */
-+
-+DUK_LOCAL void duk__sweep_heap(duk_heap *heap, duk_int_t flags, duk_size_t *out_count_keep) {
-+	duk_heaphdr *prev;  /* last element that was left in the heap */
-+	duk_heaphdr *curr;
-+	duk_heaphdr *next;
-+#ifdef DUK_USE_DEBUG
-+	duk_size_t count_free = 0;
-+	duk_size_t count_finalize = 0;
-+	duk_size_t count_rescue = 0;
-+#endif
-+	duk_size_t count_keep = 0;
-+
-+	DUK_UNREF(flags);
-+	DUK_DD(DUK_DDPRINT("duk__sweep_heap: %p", (void *) heap));
-+
-+	prev = NULL;
-+	curr = heap->heap_allocated;
-+	heap->heap_allocated = NULL;
-+	while (curr) {
-+		/* strings are never placed on the heap allocated list */
-+		DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_STRING);
-+
-+		next = DUK_HEAPHDR_GET_NEXT(heap, curr);
-+
-+		if (DUK_HEAPHDR_HAS_REACHABLE(curr)) {
-+			/*
-+			 *  Reachable object, keep
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("sweep, reachable: %p", (void *) curr));
-+
-+			if (DUK_HEAPHDR_HAS_FINALIZABLE(curr)) {
-+				/*
-+				 *  If object has been marked finalizable, move it to the
-+				 *  "to be finalized" work list.  It will be collected on
-+				 *  the next mark-and-sweep if it is still unreachable
-+				 *  after running the finalizer.
-+				 */
-+
-+				DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
-+				DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
-+				DUK_DDD(DUK_DDDPRINT("object has finalizer, move to finalization work list: %p", (void *) curr));
-+
-+#ifdef DUK_USE_DOUBLE_LINKED_HEAP
-+				if (heap->finalize_list) {
-+					DUK_HEAPHDR_SET_PREV(heap, heap->finalize_list, curr);
-+				}
-+				DUK_HEAPHDR_SET_PREV(heap, curr, NULL);
-+#endif
-+				DUK_HEAPHDR_SET_NEXT(heap, curr, heap->finalize_list);
-+				heap->finalize_list = curr;
-+#ifdef DUK_USE_DEBUG
-+				count_finalize++;
-+#endif
-+			} else {
-+				/*
-+				 *  Object will be kept; queue object back to heap_allocated (to tail)
-+				 */
-+
-+				if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
-+					/*
-+					 *  Object's finalizer was executed on last round, and
-+					 *  object has been happily rescued.
-+					 */
-+
-+					DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
-+					DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);
-+					DUK_DD(DUK_DDPRINT("object rescued during mark-and-sweep finalization: %p", (void *) curr));
-+#ifdef DUK_USE_DEBUG
-+					count_rescue++;
-+#endif
-+				} else {
-+					/*
-+					 *  Plain, boring reachable object.
-+					 */
-+					count_keep++;
-+				}
-+
-+				if (!heap->heap_allocated) {
-+					heap->heap_allocated = curr;
-+				}
-+				if (prev) {
-+					DUK_HEAPHDR_SET_NEXT(heap, prev, curr);
-+				}
-+#ifdef DUK_USE_DOUBLE_LINKED_HEAP
-+				DUK_HEAPHDR_SET_PREV(heap, curr, prev);
-+#endif
-+				prev = curr;
-+			}
-+
-+			DUK_HEAPHDR_CLEAR_REACHABLE(curr);
-+			DUK_HEAPHDR_CLEAR_FINALIZED(curr);
-+			DUK_HEAPHDR_CLEAR_FINALIZABLE(curr);
-+
-+			DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr));
-+			DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
-+			DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
-+
-+			curr = next;
-+		} else {
-+			/*
-+			 *  Unreachable object, free
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("sweep, not reachable: %p", (void *) curr));
-+
-+#if defined(DUK_USE_REFERENCE_COUNTING)
-+			/* Non-zero refcounts should not happen because we refcount
-+			 * finalize all unreachable objects which should cancel out
-+			 * refcounts (even for cycles).
-+			 */
-+			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(curr) == 0);
-+#endif
-+			DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
-+
-+			if (DUK_HEAPHDR_HAS_FINALIZED(curr)) {
-+				DUK_DDD(DUK_DDDPRINT("finalized object not rescued: %p", (void *) curr));
-+			}
-+
-+			/* Note: object cannot be a finalizable unreachable object, as
-+			 * they have been marked temporarily reachable for this round,
-+			 * and are handled above.
-+			 */
-+
-+#ifdef DUK_USE_DEBUG
-+			count_free++;
-+#endif
-+
-+			/* weak refs should be handled here, but no weak refs for
-+			 * any non-string objects exist right now.
-+			 */
-+
-+			/* free object and all auxiliary (non-heap) allocs */
-+			duk_heap_free_heaphdr_raw(heap, curr);
-+
-+			curr = next;
-+		}
-+	}
-+	if (prev) {
-+		DUK_HEAPHDR_SET_NEXT(heap, prev, NULL);
-+	}
-+
-+#ifdef DUK_USE_DEBUG
-+	DUK_D(DUK_DPRINT("mark-and-sweep sweep objects (non-string): %ld freed, %ld kept, %ld rescued, %ld queued for finalization",
-+	                 (long) count_free, (long) count_keep, (long) count_rescue, (long) count_finalize));
-+#endif
-+	*out_count_keep = count_keep;
-+}
-+
-+/*
-+ *  Run (object) finalizers in the "to be finalized" work list.
-+ */
-+
-+DUK_LOCAL void duk__run_object_finalizers(duk_heap *heap) {
-+	duk_heaphdr *curr;
-+	duk_heaphdr *next;
-+#ifdef DUK_USE_DEBUG
-+	duk_size_t count = 0;
-+#endif
-+	duk_hthread *thr;
-+
-+	DUK_DD(DUK_DDPRINT("duk__run_object_finalizers: %p", (void *) heap));
-+
-+	thr = duk__get_temp_hthread(heap);
-+	DUK_ASSERT(thr != NULL);
-+
-+	curr = heap->finalize_list;
-+	while (curr) {
-+		DUK_DDD(DUK_DDDPRINT("mark-and-sweep finalize: %p", (void *) curr));
-+
-+		DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(curr) == DUK_HTYPE_OBJECT);  /* only objects have finalizers */
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(curr));                /* flags have been already cleared */
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(curr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(curr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(curr));
-+
-+		/* run the finalizer */
-+		duk_hobject_run_finalizer(thr, (duk_hobject *) curr);  /* must never longjmp */
-+
-+		/* mark FINALIZED, for next mark-and-sweep (will collect unless has become reachable;
-+		 * prevent running finalizer again if reachable)
-+		 */
-+		DUK_HEAPHDR_SET_FINALIZED(curr);
-+
-+		/* queue back to heap_allocated */
-+		next = DUK_HEAPHDR_GET_NEXT(heap, curr);
-+		DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, curr);
-+
-+		curr = next;
-+#ifdef DUK_USE_DEBUG
-+		count++;
-+#endif
-+	}
-+
-+	/* finalize_list will always be processed completely */
-+	heap->finalize_list = NULL;
-+
-+#ifdef DUK_USE_DEBUG
-+	DUK_D(DUK_DPRINT("mark-and-sweep finalize objects: %ld finalizers called", (long) count));
-+#endif
-+}
-+
-+/*
-+ *  Object compaction.
-+ *
-+ *  Compaction is assumed to never throw an error.
-+ */
-+
-+DUK_LOCAL int duk__protected_compact_object(duk_context *ctx) {
-+	/* XXX: for threads, compact value stack, call stack, catch stack? */
-+
-+	duk_hobject *obj = duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(obj != NULL);
-+	duk_hobject_compact_props((duk_hthread *) ctx, obj);
-+	return 0;
-+}
-+
-+#ifdef DUK_USE_DEBUG
-+DUK_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start, duk_size_t *p_count_check, duk_size_t *p_count_compact, duk_size_t *p_count_bytes_saved) {
-+#else
-+DUK_LOCAL void duk__compact_object_list(duk_heap *heap, duk_hthread *thr, duk_heaphdr *start) {
-+#endif
-+	duk_heaphdr *curr;
-+#ifdef DUK_USE_DEBUG
-+	duk_size_t old_size, new_size;
-+#endif
-+	duk_hobject *obj;
-+
-+	DUK_UNREF(heap);
-+
-+	curr = start;
-+	while (curr) {
-+		DUK_DDD(DUK_DDDPRINT("mark-and-sweep compact: %p", (void *) curr));
-+
-+		if (DUK_HEAPHDR_GET_TYPE(curr) != DUK_HTYPE_OBJECT) {
-+			goto next;
-+		}
-+		obj = (duk_hobject *) curr;
-+
-+#ifdef DUK_USE_DEBUG
-+		old_size = DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),
-+		                                      DUK_HOBJECT_GET_ASIZE(obj),
-+		                                      DUK_HOBJECT_GET_HSIZE(obj));
-+#endif
-+
-+		DUK_DD(DUK_DDPRINT("compact object: %p", (void *) obj));
-+		duk_push_hobject((duk_context *) thr, obj);
-+		/* XXX: disable error handlers for duration of compaction? */
-+		duk_safe_call((duk_context *) thr, duk__protected_compact_object, 1, 0);
-+
-+#ifdef DUK_USE_DEBUG
-+		new_size = DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),
-+		                                      DUK_HOBJECT_GET_ASIZE(obj),
-+		                                      DUK_HOBJECT_GET_HSIZE(obj));
-+#endif
-+
-+#ifdef DUK_USE_DEBUG
-+		(*p_count_compact)++;
-+		(*p_count_bytes_saved) += (duk_size_t) (old_size - new_size);
-+#endif
-+
-+	 next:
-+		curr = DUK_HEAPHDR_GET_NEXT(heap, curr);
-+#ifdef DUK_USE_DEBUG
-+		(*p_count_check)++;
-+#endif
-+	}
-+}
-+
-+DUK_LOCAL void duk__compact_objects(duk_heap *heap) {
-+	/* XXX: which lists should participate?  to be finalized? */
-+#ifdef DUK_USE_DEBUG
-+	duk_size_t count_check = 0;
-+	duk_size_t count_compact = 0;
-+	duk_size_t count_bytes_saved = 0;
-+#endif
-+	duk_hthread *thr;
-+
-+	DUK_DD(DUK_DDPRINT("duk__compact_objects: %p", (void *) heap));
-+
-+	thr = duk__get_temp_hthread(heap);
-+	DUK_ASSERT(thr != NULL);
-+
-+#ifdef DUK_USE_DEBUG
-+	duk__compact_object_list(heap, thr, heap->heap_allocated, &count_check, &count_compact, &count_bytes_saved);
-+	duk__compact_object_list(heap, thr, heap->finalize_list, &count_check, &count_compact, &count_bytes_saved);
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk__compact_object_list(heap, thr, heap->refzero_list, &count_check, &count_compact, &count_bytes_saved);
-+#endif
-+#else
-+	duk__compact_object_list(heap, thr, heap->heap_allocated);
-+	duk__compact_object_list(heap, thr, heap->finalize_list);
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk__compact_object_list(heap, thr, heap->refzero_list);
-+#endif
-+#endif
-+
-+#ifdef DUK_USE_DEBUG
-+	DUK_D(DUK_DPRINT("mark-and-sweep compact objects: %ld checked, %ld compaction attempts, %ld bytes saved by compaction",
-+	                 (long) count_check, (long) count_compact, (long) count_bytes_saved));
-+#endif
-+}
-+
-+/*
-+ *  Assertion helpers.
-+ */
-+
-+#ifdef DUK_USE_ASSERTIONS
-+DUK_LOCAL void duk__assert_heaphdr_flags(duk_heap *heap) {
-+	duk_heaphdr *hdr;
-+
-+	hdr = heap->heap_allocated;
-+	while (hdr) {
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(hdr));
-+		/* may have FINALIZED */
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	hdr = heap->refzero_list;
-+	while (hdr) {
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_REACHABLE(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_TEMPROOT(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZABLE(hdr));
-+		DUK_ASSERT(!DUK_HEAPHDR_HAS_FINALIZED(hdr));
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+}
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+DUK_LOCAL void duk__assert_valid_refcounts(duk_heap *heap) {
-+	duk_heaphdr *hdr = heap->heap_allocated;
-+	while (hdr) {
-+		if (DUK_HEAPHDR_GET_REFCOUNT(hdr) == 0 &&
-+		    DUK_HEAPHDR_HAS_FINALIZED(hdr)) {
-+			/* An object may be in heap_allocated list with a zero
-+			 * refcount if it has just been finalized and is waiting
-+			 * to be collected by the next cycle.
-+			 */
-+		} else if (DUK_HEAPHDR_GET_REFCOUNT(hdr) == 0) {
-+			/* An object may be in heap_allocated list with a zero
-+			 * refcount also if it is a temporary object created by
-+			 * a finalizer; because finalization now runs inside
-+			 * mark-and-sweep, such objects will not be queued to
-+			 * refzero_list and will thus appear here with refcount
-+			 * zero.
-+			 */
-+#if 0  /* this case can no longer occur because refcount is unsigned */
-+		} else if (DUK_HEAPHDR_GET_REFCOUNT(hdr) < 0) {
-+			DUK_D(DUK_DPRINT("invalid refcount: %ld, %p -> %!O",
-+			                 (hdr != NULL ? (long) DUK_HEAPHDR_GET_REFCOUNT(hdr) : (long) 0),
-+			                 (void *) hdr, (duk_heaphdr *) hdr));
-+			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(hdr) > 0);
-+#endif
-+		}
-+		hdr = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+}
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+#endif  /* DUK_USE_ASSERTIONS */
-+
-+/*
-+ *  Main mark-and-sweep function.
-+ *
-+ *  'flags' represents the features requested by the caller.  The current
-+ *  heap->mark_and_sweep_base_flags is ORed automatically into the flags;
-+ *  the base flags mask typically prevents certain mark-and-sweep operations
-+ *  to avoid trouble.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t flags) {
-+	duk_hthread *thr;
-+	duk_size_t count_keep_obj;
-+	duk_size_t count_keep_str;
-+#ifdef DUK_USE_VOLUNTARY_GC
-+	duk_size_t tmp;
-+#endif
-+
-+	/* XXX: thread selection for mark-and-sweep is currently a hack.
-+	 * If we don't have a thread, the entire mark-and-sweep is now
-+	 * skipped (although we could just skip finalizations).
-+	 */
-+	thr = duk__get_temp_hthread(heap);
-+	if (thr == NULL) {
-+		DUK_D(DUK_DPRINT("temporary hack: gc skipped because we don't have a temp thread"));
-+
-+		/* reset voluntary gc trigger count */
-+#ifdef DUK_USE_VOLUNTARY_GC
-+		heap->mark_and_sweep_trigger_counter = DUK_HEAP_MARK_AND_SWEEP_TRIGGER_SKIP;
-+#endif
-+		return 0;  /* OK */
-+	}
-+
-+	DUK_D(DUK_DPRINT("garbage collect (mark-and-sweep) starting, requested flags: 0x%08lx, effective flags: 0x%08lx",
-+	                 (unsigned long) flags, (unsigned long) (flags | heap->mark_and_sweep_base_flags)));
-+
-+	flags |= heap->mark_and_sweep_base_flags;
-+
-+	/*
-+	 *  Assertions before
-+	 */
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap));
-+	DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap));
-+	DUK_ASSERT(heap->mark_and_sweep_recursion_depth == 0);
-+	duk__assert_heaphdr_flags(heap);
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	/* Note: DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) may be true; a refcount
-+	 * finalizer may trigger a mark-and-sweep.
-+	 */
-+	duk__assert_valid_refcounts(heap);
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+#endif  /* DUK_USE_ASSERTIONS */
-+
-+	/*
-+	 *  Begin
-+	 */
-+
-+	DUK_HEAP_SET_MARKANDSWEEP_RUNNING(heap);
-+
-+	/*
-+	 *  Mark roots, hoping that recursion limit is not normally hit.
-+	 *  If recursion limit is hit, run additional reachability rounds
-+	 *  starting from "temproots" until marking is complete.
-+	 *
-+	 *  Marking happens in two phases: first we mark actual reachability
-+	 *  roots (and run "temproots" to complete the process).  Then we
-+	 *  check which objects are unreachable and are finalizable; such
-+	 *  objects are marked as FINALIZABLE and marked as reachability
-+	 *  (and "temproots" is run again to complete the process).
-+	 *
-+	 *  The heap finalize_list must also be marked as a reachability root.
-+	 *  There may be objects on the list from a previous round if the
-+	 *  previous run had finalizer skip flag.
-+	 */
-+
-+	duk__mark_roots_heap(heap);               /* main reachability roots */
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk__mark_refzero_list(heap);             /* refzero_list treated as reachability roots */
-+#endif
-+	duk__mark_temproots_by_heap_scan(heap);   /* temproots */
-+
-+	duk__mark_finalizable(heap);              /* mark finalizable as reachability roots */
-+	duk__mark_finalize_list(heap);            /* mark finalizer work list as reachability roots */
-+	duk__mark_temproots_by_heap_scan(heap);   /* temproots */
-+
-+	/*
-+	 *  Sweep garbage and remove marking flags, and move objects with
-+	 *  finalizers to the finalizer work list.
-+	 *
-+	 *  Objects to be swept need to get their refcounts finalized before
-+	 *  they are swept.  In other words, their target object refcounts
-+	 *  need to be decreased.  This has to be done before freeing any
-+	 *  objects to avoid decref'ing dangling pointers (which may happen
-+	 *  even without bugs, e.g. with reference loops)
-+	 *
-+	 *  Because strings don't point to other heap objects, similar
-+	 *  finalization is not necessary for strings.
-+	 */
-+
-+	/* XXX: more emergency behavior, e.g. find smaller hash sizes etc */
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk__finalize_refcounts(heap);
-+#endif
-+	duk__sweep_heap(heap, flags, &count_keep_obj);
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	duk__sweep_stringtable_chain(heap, &count_keep_str);
-+#elif defined(DUK_USE_STRTAB_PROBE)
-+	duk__sweep_stringtable_probe(heap, &count_keep_str);
-+#else
-+#error internal error, invalid strtab options
-+#endif
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk__clear_refzero_list_flags(heap);
-+#endif
-+	duk__clear_finalize_list_flags(heap);
-+
-+	/*
-+	 *  Object compaction (emergency only).
-+	 *
-+	 *  Object compaction is a separate step after sweeping, as there is
-+	 *  more free memory for it to work with.  Also, currently compaction
-+	 *  may insert new objects into the heap allocated list and the string
-+	 *  table which we don't want to do during a sweep (the reachability
-+	 *  flags of such objects would be incorrect).  The objects inserted
-+	 *  are currently:
-+	 *
-+	 *    - a temporary duk_hbuffer for a new properties allocation
-+	 *    - if array part is abandoned, string keys are interned
-+	 *
-+	 *  The object insertions go to the front of the list, so they do not
-+	 *  cause an infinite loop (they are not compacted).
-+	 */
-+
-+	if ((flags & DUK_MS_FLAG_EMERGENCY) &&
-+	    !(flags & DUK_MS_FLAG_NO_OBJECT_COMPACTION)) {
-+		duk__compact_objects(heap);
-+	}
-+
-+	/*
-+	 *  String table resize check.
-+	 *
-+	 *  Note: this may silently (and safely) fail if GC is caused by an
-+	 *  allocation call in stringtable resize_hash().  Resize_hash()
-+	 *  will prevent a recursive call to itself by setting the
-+	 *  DUK_MS_FLAG_NO_STRINGTABLE_RESIZE in heap->mark_and_sweep_base_flags.
-+	 */
-+
-+	/* XXX: stringtable emergency compaction? */
-+
-+#if defined(DUK_USE_MS_STRINGTABLE_RESIZE)
-+	if (!(flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE)) {
-+		DUK_DD(DUK_DDPRINT("resize stringtable: %p", (void *) heap));
-+		duk_heap_force_strtab_resize(heap);
-+	} else {
-+		DUK_D(DUK_DPRINT("stringtable resize skipped because DUK_MS_FLAG_NO_STRINGTABLE_RESIZE is set"));
-+	}
-+#endif
-+
-+	/*
-+	 *  Finalize objects in the finalization work list.  Finalized
-+	 *  objects are queued back to heap_allocated with FINALIZED set.
-+	 *
-+	 *  Since finalizers may cause arbitrary side effects, they are
-+	 *  prevented during string table and object property allocation
-+	 *  resizing using the DUK_MS_FLAG_NO_FINALIZERS flag in
-+	 *  heap->mark_and_sweep_base_flags.  In this case the objects
-+	 *  remain in the finalization work list after mark-and-sweep
-+	 *  exits and they may be finalized on the next pass.
-+	 *
-+	 *  Finalization currently happens inside "MARKANDSWEEP_RUNNING"
-+	 *  protection (no mark-and-sweep may be triggered by the
-+	 *  finalizers).  As a side effect:
-+	 *
-+	 *    1) an out-of-memory error inside a finalizer will not
-+	 *       cause a mark-and-sweep and may cause the finalizer
-+	 *       to fail unnecessarily
-+	 *
-+	 *    2) any temporary objects whose refcount decreases to zero
-+	 *       during finalization will not be put into refzero_list;
-+	 *       they can only be collected by another mark-and-sweep
-+	 *
-+	 *  This is not optimal, but since the sweep for this phase has
-+	 *  already happened, this is probably good enough for now.
-+	 */
-+
-+	if (!(flags & DUK_MS_FLAG_NO_FINALIZERS)) {
-+		duk__run_object_finalizers(heap);
-+	} else {
-+		DUK_D(DUK_DPRINT("finalizer run skipped because DUK_MS_FLAG_NO_FINALIZERS is set"));
-+	}
-+
-+	/*
-+	 *  Finish
-+	 */
-+
-+	DUK_HEAP_CLEAR_MARKANDSWEEP_RUNNING(heap);
-+
-+	/*
-+	 *  Assertions after
-+	 */
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap));
-+	DUK_ASSERT(!DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap));
-+	DUK_ASSERT(heap->mark_and_sweep_recursion_depth == 0);
-+	duk__assert_heaphdr_flags(heap);
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	/* Note: DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap) may be true; a refcount
-+	 * finalizer may trigger a mark-and-sweep.
-+	 */
-+	duk__assert_valid_refcounts(heap);
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+#endif  /* DUK_USE_ASSERTIONS */
-+
-+	/*
-+	 *  Reset trigger counter
-+	 */
-+
-+#ifdef DUK_USE_VOLUNTARY_GC
-+	tmp = (count_keep_obj + count_keep_str) / 256;
-+	heap->mark_and_sweep_trigger_counter = (duk_int_t) (
-+	    (tmp * DUK_HEAP_MARK_AND_SWEEP_TRIGGER_MULT) +
-+	    DUK_HEAP_MARK_AND_SWEEP_TRIGGER_ADD);
-+	DUK_D(DUK_DPRINT("garbage collect (mark-and-sweep) finished: %ld objects kept, %ld strings kept, trigger reset to %ld",
-+	                 (long) count_keep_obj, (long) count_keep_str, (long) heap->mark_and_sweep_trigger_counter));
-+#else
-+	DUK_D(DUK_DPRINT("garbage collect (mark-and-sweep) finished: %ld objects kept, %ld strings kept, no voluntary trigger",
-+	                 (long) count_keep_obj, (long) count_keep_str));
-+#endif
-+
-+	return 0;  /* OK */
-+}
-+
-+#else  /* DUK_USE_MARK_AND_SWEEP */
-+
-+/* no mark-and-sweep gc */
-+
-+#endif  /* DUK_USE_MARK_AND_SWEEP */
-+#line 1 "duk_heap_memory.c"
-+/*
-+ *  Memory allocation handling.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Helpers
-+ *
-+ *  The fast path checks are done within a macro to ensure "inlining"
-+ *  while the slow path actions use a helper (which won't typically be
-+ *  inlined in size optimized builds).
-+ */
-+
-+#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_VOLUNTARY_GC)
-+#define DUK__VOLUNTARY_PERIODIC_GC(heap)  do { \
-+		(heap)->mark_and_sweep_trigger_counter--; \
-+		if ((heap)->mark_and_sweep_trigger_counter <= 0) { \
-+			duk__run_voluntary_gc(heap); \
-+		} \
-+	} while (0)
-+
-+DUK_LOCAL void duk__run_voluntary_gc(duk_heap *heap) {
-+	if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
-+		DUK_DD(DUK_DDPRINT("mark-and-sweep in progress -> skip voluntary mark-and-sweep now"));
-+	} else {
-+		duk_small_uint_t flags;
-+		duk_bool_t rc;
-+
-+		DUK_D(DUK_DPRINT("triggering voluntary mark-and-sweep"));
-+		flags = 0;
-+		rc = duk_heap_mark_and_sweep(heap, flags);
-+		DUK_UNREF(rc);
-+	}
-+}
-+#else
-+#define DUK__VOLUNTARY_PERIODIC_GC(heap)  /* no voluntary gc */
-+#endif  /* DUK_USE_MARK_AND_SWEEP && DUK_USE_VOLUNTARY_GC */
-+
-+/*
-+ *  Allocate memory with garbage collection
-+ */
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+DUK_INTERNAL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size) {
-+	void *res;
-+	duk_bool_t rc;
-+	duk_small_int_t i;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT_DISABLE(size >= 0);
-+
-+	/*
-+	 *  Voluntary periodic GC (if enabled)
-+	 */
-+
-+	DUK__VOLUNTARY_PERIODIC_GC(heap);
-+
-+	/*
-+	 *  First attempt
-+	 */
-+
-+#ifdef DUK_USE_GC_TORTURE
-+	/* simulate alloc failure on every alloc (except when mark-and-sweep is running) */
-+	if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
-+		DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first alloc attempt fails"));
-+		res = NULL;
-+		DUK_UNREF(res);
-+		goto skip_attempt;
-+	}
-+#endif
-+	res = heap->alloc_func(heap->heap_udata, size);
-+	if (res || size == 0) {
-+		/* for zero size allocations NULL is allowed */
-+		return res;
-+	}
-+#ifdef DUK_USE_GC_TORTURE
-+ skip_attempt:
-+#endif
-+
-+	DUK_D(DUK_DPRINT("first alloc attempt failed, attempt to gc and retry"));
-+
-+	/*
-+	 *  Avoid a GC if GC is already running.  This can happen at a late
-+	 *  stage in a GC when we try to e.g. resize the stringtable
-+	 *  or compact objects.
-+	 */
-+
-+	if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
-+		DUK_D(DUK_DPRINT("duk_heap_mem_alloc() failed, gc in progress (gc skipped), alloc size %ld", (long) size));
-+		return NULL;
-+	}
-+
-+	/*
-+	 *  Retry with several GC attempts.  Initial attempts are made without
-+	 *  emergency mode; later attempts use emergency mode which minimizes
-+	 *  memory allocations forcibly.
-+	 */
-+
-+	for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
-+		duk_small_uint_t flags;
-+
-+		flags = 0;
-+		if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {
-+			flags |= DUK_MS_FLAG_EMERGENCY;
-+		}
-+
-+		rc = duk_heap_mark_and_sweep(heap, flags);
-+		DUK_UNREF(rc);
-+
-+		res = heap->alloc_func(heap->heap_udata, size);
-+		if (res) {
-+			DUK_D(DUK_DPRINT("duk_heap_mem_alloc() succeeded after gc (pass %ld), alloc size %ld",
-+			                 (long) (i + 1), (long) size));
-+			return res;
-+		}
-+	}
-+
-+	DUK_D(DUK_DPRINT("duk_heap_mem_alloc() failed even after gc, alloc size %ld", (long) size));
-+	return NULL;
-+}
-+#else  /* DUK_USE_MARK_AND_SWEEP */
-+/*
-+ *  Compared to a direct macro expansion this wrapper saves a few
-+ *  instructions because no heap dereferencing is required.
-+ */
-+DUK_INTERNAL void *duk_heap_mem_alloc(duk_heap *heap, duk_size_t size) {
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT_DISABLE(size >= 0);
-+
-+	return heap->alloc_func(heap->heap_udata, size);
-+}
-+#endif  /* DUK_USE_MARK_AND_SWEEP */
-+
-+DUK_INTERNAL void *duk_heap_mem_alloc_zeroed(duk_heap *heap, duk_size_t size) {
-+	void *res;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT_DISABLE(size >= 0);
-+
-+	res = DUK_ALLOC(heap, size);
-+	if (res) {
-+		/* assume memset with zero size is OK */
-+		DUK_MEMZERO(res, size);
-+	}
-+	return res;
-+}
-+
-+/*
-+ *  Reallocate memory with garbage collection
-+ */
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+DUK_INTERNAL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize) {
-+	void *res;
-+	duk_bool_t rc;
-+	duk_small_int_t i;
-+
-+	DUK_ASSERT(heap != NULL);
-+	/* ptr may be NULL */
-+	DUK_ASSERT_DISABLE(newsize >= 0);
-+
-+	/*
-+	 *  Voluntary periodic GC (if enabled)
-+	 */
-+
-+	DUK__VOLUNTARY_PERIODIC_GC(heap);
-+
-+	/*
-+	 *  First attempt
-+	 */
-+
-+#ifdef DUK_USE_GC_TORTURE
-+	/* simulate alloc failure on every realloc (except when mark-and-sweep is running) */
-+	if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
-+		DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first realloc attempt fails"));
-+		res = NULL;
-+		DUK_UNREF(res);
-+		goto skip_attempt;
-+	}
-+#endif
-+	res = heap->realloc_func(heap->heap_udata, ptr, newsize);
-+	if (res || newsize == 0) {
-+		/* for zero size allocations NULL is allowed */
-+		return res;
-+	}
-+#ifdef DUK_USE_GC_TORTURE
-+ skip_attempt:
-+#endif
-+
-+	DUK_D(DUK_DPRINT("first realloc attempt failed, attempt to gc and retry"));
-+
-+	/*
-+	 *  Avoid a GC if GC is already running.  See duk_heap_mem_alloc().
-+	 */
-+
-+	if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
-+		DUK_D(DUK_DPRINT("duk_heap_mem_realloc() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize));
-+		return NULL;
-+	}
-+
-+	/*
-+	 *  Retry with several GC attempts.  Initial attempts are made without
-+	 *  emergency mode; later attempts use emergency mode which minimizes
-+	 *  memory allocations forcibly.
-+	 */
-+
-+	for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
-+		duk_small_uint_t flags;
-+
-+		flags = 0;
-+		if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {
-+			flags |= DUK_MS_FLAG_EMERGENCY;
-+		}
-+
-+		rc = duk_heap_mark_and_sweep(heap, flags);
-+		DUK_UNREF(rc);
-+
-+		res = heap->realloc_func(heap->heap_udata, ptr, newsize);
-+		if (res || newsize == 0) {
-+			DUK_D(DUK_DPRINT("duk_heap_mem_realloc() succeeded after gc (pass %ld), alloc size %ld",
-+			                 (long) (i + 1), (long) newsize));
-+			return res;
-+		}
-+	}
-+
-+	DUK_D(DUK_DPRINT("duk_heap_mem_realloc() failed even after gc, alloc size %ld", (long) newsize));
-+	return NULL;
-+}
-+#else  /* DUK_USE_MARK_AND_SWEEP */
-+/* saves a few instructions to have this wrapper (see comment on duk_heap_mem_alloc) */
-+DUK_INTERNAL void *duk_heap_mem_realloc(duk_heap *heap, void *ptr, duk_size_t newsize) {
-+	DUK_ASSERT(heap != NULL);
-+	/* ptr may be NULL */
-+	DUK_ASSERT_DISABLE(newsize >= 0);
-+
-+	return heap->realloc_func(heap->heap_udata, ptr, newsize);
-+}
-+#endif  /* DUK_USE_MARK_AND_SWEEP */
-+
-+/*
-+ *  Reallocate memory with garbage collection, using a callback to provide
-+ *  the current allocated pointer.  This variant is used when a mark-and-sweep
-+ *  (e.g. finalizers) might change the original pointer.
-+ */
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+DUK_INTERNAL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize) {
-+	void *res;
-+	duk_bool_t rc;
-+	duk_small_int_t i;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT_DISABLE(newsize >= 0);
-+
-+	/*
-+	 *  Voluntary periodic GC (if enabled)
-+	 */
-+
-+	DUK__VOLUNTARY_PERIODIC_GC(heap);
-+
-+	/*
-+	 *  First attempt
-+	 */
-+
-+#ifdef DUK_USE_GC_TORTURE
-+	/* simulate alloc failure on every realloc (except when mark-and-sweep is running) */
-+	if (!DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
-+		DUK_DDD(DUK_DDDPRINT("gc torture enabled, pretend that first indirect realloc attempt fails"));
-+		res = NULL;
-+		DUK_UNREF(res);
-+		goto skip_attempt;
-+	}
-+#endif
-+	res = heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
-+	if (res || newsize == 0) {
-+		/* for zero size allocations NULL is allowed */
-+		return res;
-+	}
-+#ifdef DUK_USE_GC_TORTURE
-+ skip_attempt:
-+#endif
-+
-+	DUK_D(DUK_DPRINT("first indirect realloc attempt failed, attempt to gc and retry"));
-+
-+	/*
-+	 *  Avoid a GC if GC is already running.  See duk_heap_mem_alloc().
-+	 */
-+
-+	if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
-+		DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() failed, gc in progress (gc skipped), alloc size %ld", (long) newsize));
-+		return NULL;
-+	}
-+
-+	/*
-+	 *  Retry with several GC attempts.  Initial attempts are made without
-+	 *  emergency mode; later attempts use emergency mode which minimizes
-+	 *  memory allocations forcibly.
-+	 */
-+
-+	for (i = 0; i < DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT; i++) {
-+		duk_small_uint_t flags;
-+
-+#ifdef DUK_USE_ASSERTIONS
-+		void *ptr_pre;  /* ptr before mark-and-sweep */
-+		void *ptr_post;
-+#endif
-+
-+#ifdef DUK_USE_ASSERTIONS
-+		ptr_pre = cb(heap, ud);
-+#endif
-+		flags = 0;
-+		if (i >= DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT - 1) {
-+			flags |= DUK_MS_FLAG_EMERGENCY;
-+		}
-+
-+		rc = duk_heap_mark_and_sweep(heap, flags);
-+		DUK_UNREF(rc);
-+#ifdef DUK_USE_ASSERTIONS
-+		ptr_post = cb(heap, ud);
-+		if (ptr_pre != ptr_post) {
-+			/* useful for debugging */
-+			DUK_DD(DUK_DDPRINT("note: base pointer changed by mark-and-sweep: %p -> %p",
-+			                   (void *) ptr_pre, (void *) ptr_post));
-+		}
-+#endif
-+
-+		/* Note: key issue here is to re-lookup the base pointer on every attempt.
-+		 * The pointer being reallocated may change after every mark-and-sweep.
-+		 */
-+
-+		res = heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
-+		if (res || newsize == 0) {
-+			DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() succeeded after gc (pass %ld), alloc size %ld",
-+			                 (long) (i + 1), (long) newsize));
-+			return res;
-+		}
-+	}
-+
-+	DUK_D(DUK_DPRINT("duk_heap_mem_realloc_indirect() failed even after gc, alloc size %ld", (long) newsize));
-+	return NULL;
-+}
-+#else  /* DUK_USE_MARK_AND_SWEEP */
-+/* saves a few instructions to have this wrapper (see comment on duk_heap_mem_alloc) */
-+DUK_INTERNAL void *duk_heap_mem_realloc_indirect(duk_heap *heap, duk_mem_getptr cb, void *ud, duk_size_t newsize) {
-+	return heap->realloc_func(heap->heap_udata, cb(heap, ud), newsize);
-+}
-+#endif  /* DUK_USE_MARK_AND_SWEEP */
-+
-+/*
-+ *  Free memory
-+ */
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+DUK_INTERNAL void duk_heap_mem_free(duk_heap *heap, void *ptr) {
-+	DUK_ASSERT(heap != NULL);
-+	/* ptr may be NULL */
-+
-+	/* Must behave like a no-op with NULL and any pointer returned from
-+	 * malloc/realloc with zero size.
-+	 */
-+	heap->free_func(heap->heap_udata, ptr);
-+
-+	/* Count free operations toward triggering a GC but never actually trigger
-+	 * a GC from a free.  Otherwise code which frees internal structures would
-+	 * need to put in NULLs at every turn to ensure the object is always in
-+	 * consistent state for a mark-and-sweep.
-+	 */
-+#ifdef DUK_USE_VOLUNTARY_GC
-+	heap->mark_and_sweep_trigger_counter--;
-+#endif
-+}
-+#else
-+/* saves a few instructions to have this wrapper (see comment on duk_heap_mem_alloc) */
-+DUK_INTERNAL void duk_heap_mem_free(duk_heap *heap, void *ptr) {
-+	DUK_ASSERT(heap != NULL);
-+	/* ptr may be NULL */
-+
-+	/* Note: must behave like a no-op with NULL and any pointer
-+	 * returned from malloc/realloc with zero size.
-+	 */
-+	heap->free_func(heap->heap_udata, ptr);
-+}
-+#endif
-+#line 1 "duk_heap_misc.c"
-+/*
-+ *  Support functions for duk_heap.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#if defined(DUK_USE_DOUBLE_LINKED_HEAP) && defined(DUK_USE_REFERENCE_COUNTING)
-+/* arbitrary remove only works with double linked heap, and is only required by
-+ * reference counting so far.
-+ */
-+DUK_INTERNAL void duk_heap_remove_any_from_heap_allocated(duk_heap *heap, duk_heaphdr *hdr) {
-+	DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(hdr) != DUK_HTYPE_STRING);
-+
-+	if (DUK_HEAPHDR_GET_PREV(heap, hdr)) {
-+		DUK_HEAPHDR_SET_NEXT(heap, DUK_HEAPHDR_GET_PREV(heap, hdr), DUK_HEAPHDR_GET_NEXT(heap, hdr));
-+	} else {
-+		heap->heap_allocated = DUK_HEAPHDR_GET_NEXT(heap, hdr);
-+	}
-+	if (DUK_HEAPHDR_GET_NEXT(heap, hdr)) {
-+		DUK_HEAPHDR_SET_PREV(heap, DUK_HEAPHDR_GET_NEXT(heap, hdr), DUK_HEAPHDR_GET_PREV(heap, hdr));
-+	} else {
-+		;
-+	}
-+}
-+#endif
-+
-+DUK_INTERNAL void duk_heap_insert_into_heap_allocated(duk_heap *heap, duk_heaphdr *hdr) {
-+	DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(hdr) != DUK_HTYPE_STRING);
-+
-+#ifdef DUK_USE_DOUBLE_LINKED_HEAP
-+	if (heap->heap_allocated) {
-+		DUK_ASSERT(DUK_HEAPHDR_GET_PREV(heap, heap->heap_allocated) == NULL);
-+		DUK_HEAPHDR_SET_PREV(heap, heap->heap_allocated, hdr);
-+	}
-+	DUK_HEAPHDR_SET_PREV(heap, hdr, NULL);
-+#endif
-+	DUK_HEAPHDR_SET_NEXT(heap, hdr, heap->heap_allocated);
-+	heap->heap_allocated = hdr;
-+}
-+
-+#ifdef DUK_USE_INTERRUPT_COUNTER
-+DUK_INTERNAL void duk_heap_switch_thread(duk_heap *heap, duk_hthread *new_thr) {
-+	/* Copy currently active interrupt counter from the active thread
-+	 * back to the heap structure.  It doesn't need to be copied to
-+	 * the target thread, as the bytecode executor does that when it
-+	 * resumes execution for a new thread.
-+	 */
-+	if (heap->curr_thread != NULL) {
-+		heap->interrupt_counter = heap->curr_thread->interrupt_counter;
-+	}
-+	heap->curr_thread = new_thr;  /* may be NULL */
-+}
-+#endif  /* DUK_USE_INTERRUPT_COUNTER */
-+#line 1 "duk_heap_refcount.c"
-+/*
-+ *  Reference counting implementation.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+
-+#ifndef DUK_USE_DOUBLE_LINKED_HEAP
-+#error internal error, reference counting requires a double linked heap
-+#endif
-+
-+/*
-+ *  Misc
-+ */
-+
-+DUK_LOCAL void duk__queue_refzero(duk_heap *heap, duk_heaphdr *hdr) {
-+	/* tail insert: don't disturb head in case refzero is running */
-+
-+	if (heap->refzero_list != NULL) {
-+		duk_heaphdr *hdr_prev;
-+
-+		hdr_prev = heap->refzero_list_tail;
-+		DUK_ASSERT(hdr_prev != NULL);
-+		DUK_ASSERT(DUK_HEAPHDR_GET_NEXT(heap, hdr_prev) == NULL);
-+
-+		DUK_HEAPHDR_SET_NEXT(heap, hdr, NULL);
-+		DUK_HEAPHDR_SET_PREV(heap, hdr, hdr_prev);
-+		DUK_HEAPHDR_SET_NEXT(heap, hdr_prev, hdr);
-+		heap->refzero_list_tail = hdr;
-+	} else {
-+		DUK_ASSERT(heap->refzero_list_tail == NULL);
-+		DUK_HEAPHDR_SET_NEXT(heap, hdr, NULL);
-+		DUK_HEAPHDR_SET_PREV(heap, hdr, NULL);
-+		heap->refzero_list = hdr;
-+		heap->refzero_list_tail = hdr;
-+	}
-+}
-+
-+/*
-+ *  Heap object refcount finalization.
-+ *
-+ *  When an object is about to be freed, all other objects it refers to must
-+ *  be decref'd.  Refcount finalization does NOT free the object or its inner
-+ *  allocations (mark-and-sweep shares these helpers), it just manipulates
-+ *  the refcounts.
-+ *
-+ *  Note that any of the decref's may cause a refcount to drop to zero, BUT
-+ *  it will not be processed inline; instead, because refzero is already
-+ *  running, the objects will just be queued to refzero list and processed
-+ *  later.  This eliminates C recursion.
-+ */
-+
-+DUK_LOCAL void duk__refcount_finalize_hobject(duk_hthread *thr, duk_hobject *h) {
-+	duk_uint_fast32_t i;
-+
-+	DUK_ASSERT(h);
-+	DUK_ASSERT(DUK_HEAPHDR_GET_TYPE((duk_heaphdr *) h) == DUK_HTYPE_OBJECT);
-+
-+	/* XXX: better to get base and walk forwards? */
-+
-+	for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h); i++) {
-+		duk_hstring *key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i);
-+		if (!key) {
-+			continue;
-+		}
-+		duk_heaphdr_decref(thr, (duk_heaphdr *) key);
-+		if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i)) {
-+			duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, h, i));
-+			duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, h, i));
-+		} else {
-+			duk_tval_decref(thr, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i));
-+		}
-+	}
-+
-+	for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(h); i++) {
-+		duk_tval_decref(thr, DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, h, i));
-+	}
-+
-+	/* hash part is a 'weak reference' and does not contribute */
-+
-+	duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h));
-+
-+	if (DUK_HOBJECT_IS_COMPILEDFUNCTION(h)) {
-+		duk_hcompiledfunction *f = (duk_hcompiledfunction *) h;
-+		duk_tval *tv, *tv_end;
-+		duk_hobject **funcs, **funcs_end;
-+
-+		DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f) != NULL);  /* compiled functions must be created 'atomically' */
-+
-+		tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, f);
-+		tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, f);
-+		while (tv < tv_end) {
-+			duk_tval_decref(thr, tv);
-+			tv++;
-+		}
-+
-+		funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, f);
-+		funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, f);
-+		while (funcs < funcs_end) {
-+			duk_heaphdr_decref(thr, (duk_heaphdr *) *funcs);
-+			funcs++;
-+		}
-+
-+		duk_heaphdr_decref(thr, (duk_heaphdr *) DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f));
-+	} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(h)) {
-+		duk_hnativefunction *f = (duk_hnativefunction *) h;
-+		DUK_UNREF(f);
-+		/* nothing to finalize */
-+	} else if (DUK_HOBJECT_IS_THREAD(h)) {
-+		duk_hthread *t = (duk_hthread *) h;
-+		duk_tval *tv;
-+
-+		tv = t->valstack;
-+		while (tv < t->valstack_end) {
-+			duk_tval_decref(thr, tv);
-+			tv++;
-+		}
-+
-+		for (i = 0; i < (duk_uint_fast32_t) t->callstack_top; i++) {
-+			duk_activation *act = t->callstack + i;
-+			duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) DUK_ACT_GET_FUNC(act));
-+			duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->var_env);
-+			duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->lex_env);
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+			duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) act->prev_caller);
-+#endif
-+		}
-+
-+#if 0  /* nothing now */
-+		for (i = 0; i < (duk_uint_fast32_t) t->catchstack_top; i++) {
-+			duk_catcher *cat = t->catchstack + i;
-+		}
-+#endif
-+
-+		for (i = 0; i < DUK_NUM_BUILTINS; i++) {
-+			duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->builtins[i]);
-+		}
-+
-+		duk_heaphdr_decref_allownull(thr, (duk_heaphdr *) t->resumer);
-+	}
-+}
-+
-+DUK_INTERNAL void duk_heaphdr_refcount_finalize(duk_hthread *thr, duk_heaphdr *hdr) {
-+	DUK_ASSERT(hdr);
-+
-+	switch ((int) DUK_HEAPHDR_GET_TYPE(hdr)) {
-+	case DUK_HTYPE_OBJECT:
-+		duk__refcount_finalize_hobject(thr, (duk_hobject *) hdr);
-+		break;
-+	case DUK_HTYPE_BUFFER:
-+		/* nothing to finalize */
-+		break;
-+	case DUK_HTYPE_STRING:
-+		/* cannot happen: strings are not put into refzero list (they don't even have the next/prev pointers) */
-+	default:
-+		DUK_UNREACHABLE();
-+	}
-+}
-+
-+/*
-+ *  Refcount memory freeing loop.
-+ *
-+ *  Frees objects in the refzero_pending list until the list becomes
-+ *  empty.  When an object is freed, its references get decref'd and
-+ *  may cause further objects to be queued for freeing.
-+ *
-+ *  This could be expanded to allow incremental freeing: just bail out
-+ *  early and resume at a future alloc/decref/refzero.
-+ */
-+
-+DUK_LOCAL void duk__refzero_free_pending(duk_hthread *thr) {
-+	duk_heaphdr *h1, *h2;
-+	duk_heap *heap;
-+	duk_int_t count = 0;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	heap = thr->heap;
-+	DUK_ASSERT(heap != NULL);
-+
-+	/*
-+	 *  Detect recursive invocation
-+	 */
-+
-+	if (DUK_HEAP_HAS_REFZERO_FREE_RUNNING(heap)) {
-+		DUK_DDD(DUK_DDDPRINT("refzero free running, skip run"));
-+		return;
-+	}
-+
-+	/*
-+	 *  Churn refzero_list until empty
-+	 */
-+
-+	DUK_HEAP_SET_REFZERO_FREE_RUNNING(heap);
-+	while (heap->refzero_list) {
-+		duk_hobject *obj;
-+		duk_bool_t rescued = 0;
-+
-+		/*
-+		 *  Pick an object from the head (don't remove yet).
-+		 */
-+
-+		h1 = heap->refzero_list;
-+		obj = (duk_hobject *) h1;
-+		DUK_DD(DUK_DDPRINT("refzero processing %p: %!O", (void *) h1, (duk_heaphdr *) h1));
-+		DUK_ASSERT(DUK_HEAPHDR_GET_PREV(heap, h1) == NULL);
-+		DUK_ASSERT(DUK_HEAPHDR_GET_TYPE(h1) == DUK_HTYPE_OBJECT);  /* currently, always the case */
-+
-+		/*
-+		 *  Finalizer check.
-+		 *
-+		 *  Note: running a finalizer may have arbitrary side effects, e.g.
-+		 *  queue more objects on refzero_list (tail), or even trigger a
-+		 *  mark-and-sweep.
-+		 *
-+		 *  Note: quick reject check should match vast majority of
-+		 *  objects and must be safe (not throw any errors, ever).
-+		 */
-+
-+		/* XXX: If object has FINALIZED, it was finalized by mark-and-sweep on
-+		 * its previous run.  Any point in running finalizer again here?  If
-+		 * finalization semantics is changed so that finalizer is only run once,
-+		 * checking for FINALIZED would happen here.
-+		 */
-+
-+		/* A finalizer is looked up from the object and up its prototype chain
-+		 * (which allows inherited finalizers).
-+		 */
-+		if (duk_hobject_hasprop_raw(thr, obj, DUK_HTHREAD_STRING_INT_FINALIZER(thr))) {
-+			DUK_DDD(DUK_DDDPRINT("object has a finalizer, run it"));
-+
-+			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h1) == 0);
-+			DUK_HEAPHDR_PREINC_REFCOUNT(h1);  /* bump refcount to prevent refzero during finalizer processing */
-+
-+			duk_hobject_run_finalizer(thr, obj);  /* must never longjmp */
-+
-+			DUK_HEAPHDR_PREDEC_REFCOUNT(h1);  /* remove artificial bump */
-+			DUK_ASSERT_DISABLE(h1->h_refcount >= 0);  /* refcount is unsigned, so always true */
-+
-+			if (DUK_HEAPHDR_GET_REFCOUNT(h1) != 0) {
-+				DUK_DDD(DUK_DDDPRINT("-> object refcount after finalization non-zero, object will be rescued"));
-+				rescued = 1;
-+			} else {
-+				DUK_DDD(DUK_DDDPRINT("-> object refcount still zero after finalization, object will be freed"));
-+			}
-+		}
-+
-+		/* Refzero head is still the same.  This is the case even if finalizer
-+		 * inserted more refzero objects; they are inserted to the tail.
-+		 */
-+		DUK_ASSERT(h1 == heap->refzero_list);
-+
-+		/*
-+		 *  Remove the object from the refzero list.  This cannot be done
-+		 *  before a possible finalizer has been executed; the finalizer
-+		 *  may trigger a mark-and-sweep, and mark-and-sweep must be able
-+		 *  to traverse a complete refzero_list.
-+		 */
-+
-+		h2 = DUK_HEAPHDR_GET_NEXT(heap, h1);
-+		if (h2) {
-+			DUK_HEAPHDR_SET_PREV(heap, h2, NULL);  /* not strictly necessary */
-+			heap->refzero_list = h2;
-+		} else {
-+			heap->refzero_list = NULL;
-+			heap->refzero_list_tail = NULL;
-+		}
-+
-+		/*
-+		 *  Rescue or free.
-+		 */
-+
-+		if (rescued) {
-+			/* yes -> move back to heap allocated */
-+			DUK_DD(DUK_DDPRINT("object rescued during refcount finalization: %p", (void *) h1));
-+			DUK_HEAPHDR_SET_PREV(heap, h1, NULL);
-+			DUK_HEAPHDR_SET_NEXT(heap, h1, heap->heap_allocated);
-+			heap->heap_allocated = h1;
-+		} else {
-+			/* no -> decref members, then free */
-+			duk__refcount_finalize_hobject(thr, obj);
-+			duk_heap_free_heaphdr_raw(heap, h1);
-+		}
-+
-+		count++;
-+	}
-+	DUK_HEAP_CLEAR_REFZERO_FREE_RUNNING(heap);
-+
-+	DUK_DDD(DUK_DDDPRINT("refzero processed %ld objects", (long) count));
-+
-+	/*
-+	 *  Once the whole refzero cascade has been freed, check for
-+	 *  a voluntary mark-and-sweep.
-+	 */
-+
-+#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_VOLUNTARY_GC)
-+	/* 'count' is more or less comparable to normal trigger counter update
-+	 * which happens in memory block (re)allocation.
-+	 */
-+	heap->mark_and_sweep_trigger_counter -= count;
-+	if (heap->mark_and_sweep_trigger_counter <= 0) {
-+		duk_bool_t rc;
-+		duk_small_uint_t flags = 0;  /* not emergency */
-+		DUK_D(DUK_DPRINT("refcount triggering mark-and-sweep"));
-+		rc = duk_heap_mark_and_sweep(heap, flags);
-+		DUK_UNREF(rc);
-+		DUK_D(DUK_DPRINT("refcount triggered mark-and-sweep => rc %ld", (long) rc));
-+	}
-+#endif  /* DUK_USE_MARK_AND_SWEEP && DUK_USE_VOLUNTARY_GC */
-+}
-+
-+/*
-+ *  Incref and decref functions.
-+ *
-+ *  Decref may trigger immediate refzero handling, which may free and finalize
-+ *  an arbitrary number of objects.
-+ *
-+ */
-+
-+DUK_INTERNAL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h) {
-+	duk_heap *heap;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(h != NULL);
-+
-+	heap = thr->heap;
-+	DUK_DDD(DUK_DDDPRINT("refzero %p: %!O", (void *) h, (duk_heaphdr *) h));
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	/*
-+	 *  If mark-and-sweep is running, don't process 'refzero' situations at all.
-+	 *  They may happen because mark-and-sweep needs to finalize refcounts for
-+	 *  each object it sweeps.  Otherwise the target objects of swept objects
-+	 *  would have incorrect refcounts.
-+	 *
-+	 *  Note: mark-and-sweep could use a separate decref handler to avoid coming
-+	 *  here at all.  However, mark-and-sweep may also call finalizers, which
-+	 *  can do arbitrary operations and would use this decref variant anyway.
-+	 */
-+	if (DUK_HEAP_HAS_MARKANDSWEEP_RUNNING(heap)) {
-+		DUK_DDD(DUK_DDDPRINT("refzero handling suppressed when mark-and-sweep running, object: %p", (void *) h));
-+		return;
-+	}
-+#endif
-+
-+	switch ((duk_small_int_t) DUK_HEAPHDR_GET_TYPE(h)) {
-+	case DUK_HTYPE_STRING:
-+		/*
-+		 *  Strings have no internal references but do have "weak"
-+		 *  references in the string cache.  Also note that strings
-+		 *  are not on the heap_allocated list like other heap
-+		 *  elements.
-+		 */
-+
-+		duk_heap_strcache_string_remove(heap, (duk_hstring *) h);
-+		duk_heap_string_remove(heap, (duk_hstring *) h);
-+		duk_heap_free_heaphdr_raw(heap, h);
-+		break;
-+
-+	case DUK_HTYPE_OBJECT:
-+		/*
-+		 *  Objects have internal references.  Must finalize through
-+		 *  the "refzero" work list.
-+		 */
-+
-+		duk_heap_remove_any_from_heap_allocated(heap, h);
-+		duk__queue_refzero(heap, h);
-+		duk__refzero_free_pending(thr);
-+		break;
-+
-+	case DUK_HTYPE_BUFFER:
-+		/*
-+		 *  Buffers have no internal references.  However, a dynamic
-+		 *  buffer has a separate allocation for the buffer.  This is
-+		 *  freed by duk_heap_free_heaphdr_raw().
-+		 */
-+
-+		duk_heap_remove_any_from_heap_allocated(heap, h);
-+		duk_heap_free_heaphdr_raw(heap, h);
-+		break;
-+
-+	default:
-+		DUK_D(DUK_DPRINT("invalid heap type in decref: %ld", (long) DUK_HEAPHDR_GET_TYPE(h)));
-+		DUK_UNREACHABLE();
-+	}
-+}
-+
-+#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
-+DUK_INTERNAL void duk_tval_incref(duk_tval *tv) {
-+	DUK_ASSERT(tv != NULL);
-+
-+	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
-+		DUK_ASSERT(h != NULL);
-+		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
-+		DUK_ASSERT_DISABLE(h->h_refcount >= 0);
-+		DUK_HEAPHDR_PREINC_REFCOUNT(h);
-+	}
-+}
-+#endif
-+
-+#if 0  /* unused */
-+DUK_INTERNAL void duk_tval_incref_allownull(duk_tval *tv) {
-+	if (tv == NULL) {
-+		return;
-+	}
-+	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
-+		DUK_ASSERT(h != NULL);
-+		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
-+		DUK_ASSERT_DISABLE(h->h_refcount >= 0);
-+		DUK_HEAPHDR_PREINC_REFCOUNT(h);
-+	}
-+}
-+#endif
-+
-+DUK_INTERNAL void duk_tval_decref(duk_hthread *thr, duk_tval *tv) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(tv != NULL);
-+
-+	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
-+		DUK_ASSERT(h != NULL);
-+		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
-+		duk_heaphdr_decref(thr, h);
-+	}
-+}
-+
-+#if 0  /* unused */
-+DUK_INTERNAL void duk_tval_decref_allownull(duk_hthread *thr, duk_tval *tv) {
-+	DUK_ASSERT(thr != NULL);
-+
-+	if (tv == NULL) {
-+		return;
-+	}
-+	if (DUK_TVAL_IS_HEAP_ALLOCATED(tv)) {
-+		duk_heaphdr *h = DUK_TVAL_GET_HEAPHDR(tv);
-+		DUK_ASSERT(h != NULL);
-+		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
-+		duk_heaphdr_decref(thr, h);
-+	}
-+}
-+#endif
-+
-+#if !defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
-+DUK_INTERNAL void duk_heaphdr_incref(duk_heaphdr *h) {
-+	DUK_ASSERT(h != NULL);
-+	DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
-+	DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0);
-+
-+	DUK_HEAPHDR_PREINC_REFCOUNT(h);
-+}
-+#endif
-+
-+#if 0  /* unused */
-+DUK_INTERNAL void duk_heaphdr_incref_allownull(duk_heaphdr *h) {
-+	if (h == NULL) {
-+		return;
-+	}
-+	DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
-+	DUK_ASSERT_DISABLE(DUK_HEAPHDR_GET_REFCOUNT(h) >= 0);
-+
-+	DUK_HEAPHDR_PREINC_REFCOUNT(h);
-+}
-+#endif
-+
-+DUK_INTERNAL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(h != NULL);
-+	DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
-+	DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h) >= 1);
-+
-+	if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) {
-+		return;
-+	}
-+	duk_heaphdr_refzero(thr, h);
-+}
-+
-+DUK_INTERNAL void duk_heaphdr_decref_allownull(duk_hthread *thr, duk_heaphdr *h) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+
-+	if (h == NULL) {
-+		return;
-+	}
-+
-+	DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(h));
-+	DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(h) >= 1);
-+
-+	if (DUK_HEAPHDR_PREDEC_REFCOUNT(h) != 0) {
-+		return;
-+	}
-+	duk_heaphdr_refzero(thr, h);
-+}
-+
-+#else
-+
-+/* no refcounting */
-+
-+#endif  /* DUK_USE_REFERENCE_COUNTING */
-+#line 1 "duk_heap_stringcache.c"
-+/*
-+ *  String cache.
-+ *
-+ *  Provides a cache to optimize indexed string lookups.  The cache keeps
-+ *  track of (byte offset, char offset) states for a fixed number of strings.
-+ *  Otherwise we'd need to scan from either end of the string, as we store
-+ *  strings in (extended) UTF-8.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Delete references to given hstring from the heap string cache.
-+ *
-+ *  String cache references are 'weak': they are not counted towards
-+ *  reference counts, nor serve as roots for mark-and-sweep.  When an
-+ *  object is about to be freed, such references need to be removed.
-+ */
-+
-+DUK_INTERNAL void duk_heap_strcache_string_remove(duk_heap *heap, duk_hstring *h) {
-+	duk_small_int_t i;
-+	for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-+		duk_strcache *c = heap->strcache + i;
-+		if (c->h == h) {
-+			DUK_DD(DUK_DDPRINT("deleting weak strcache reference to hstring %p from heap %p",
-+			                   (void *) h, (void *) heap));
-+			c->h = NULL;
-+
-+			/* XXX: the string shouldn't appear twice, but we now loop to the
-+			 * end anyway; if fixed, add a looping assertion to ensure there
-+			 * is no duplicate.
-+			 */
-+		}
-+	}
-+}
-+
-+/*
-+ *  String scanning helpers
-+ */
-+
-+DUK_LOCAL duk_uint8_t *duk__scan_forwards(duk_uint8_t *p, duk_uint8_t *q, duk_uint_fast32_t n) {
-+	while (n > 0) {
-+		for (;;) {
-+			p++;
-+			if (p >= q) {
-+				return NULL;
-+			}
-+			if ((*p & 0xc0) != 0x80) {
-+				break;
-+			}
-+		}
-+		n--;
-+	}
-+	return p;
-+}
-+
-+DUK_LOCAL duk_uint8_t *duk__scan_backwards(duk_uint8_t *p, duk_uint8_t *q, duk_uint_fast32_t n) {
-+	while (n > 0) {
-+		for (;;) {
-+			p--;
-+			if (p < q) {
-+				return NULL;
-+			}
-+			if ((*p & 0xc0) != 0x80) {
-+				break;
-+			}
-+		}
-+		n--;
-+	}
-+	return p;
-+}
-+
-+/*
-+ *  Convert char offset to byte offset
-+ *
-+ *  Avoid using the string cache if possible: for ASCII strings byte and
-+ *  char offsets are equal and for short strings direct scanning may be
-+ *  better than using the string cache (which may evict a more important
-+ *  entry).
-+ *
-+ *  Typing now assumes 32-bit string byte/char offsets (duk_uint_fast32_t).
-+ *  Better typing might be to use duk_size_t.
-+ */
-+
-+DUK_INTERNAL duk_uint_fast32_t duk_heap_strcache_offset_char2byte(duk_hthread *thr, duk_hstring *h, duk_uint_fast32_t char_offset) {
-+	duk_heap *heap;
-+	duk_strcache *sce;
-+	duk_uint_fast32_t byte_offset;
-+	duk_small_int_t i;
-+	duk_bool_t use_cache;
-+	duk_uint_fast32_t dist_start, dist_end, dist_sce;
-+	duk_uint8_t *p_start;
-+	duk_uint8_t *p_end;
-+	duk_uint8_t *p_found;
-+
-+	if (char_offset > DUK_HSTRING_GET_CHARLEN(h)) {
-+		goto error;
-+	}
-+
-+	/*
-+	 *  For ASCII strings, the answer is simple.
-+	 */
-+
-+	if (DUK_HSTRING_IS_ASCII(h)) {
-+		/* clen == blen -> pure ascii */
-+		return char_offset;
-+	}
-+
-+	/*
-+	 *  For non-ASCII strings, we need to scan forwards or backwards
-+	 *  from some starting point.  The starting point may be the start
-+	 *  or end of the string, or some cached midpoint in the string
-+	 *  cache.
-+	 *
-+	 *  For "short" strings we simply scan without checking or updating
-+	 *  the cache.  For longer strings we check and update the cache as
-+	 *  necessary, inserting a new cache entry if none exists.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("non-ascii string %p, char_offset=%ld, clen=%ld, blen=%ld",
-+	                     (void *) h, (long) char_offset,
-+	                     (long) DUK_HSTRING_GET_CHARLEN(h),
-+	                     (long) DUK_HSTRING_GET_BYTELEN(h)));
-+
-+	heap = thr->heap;
-+	sce = NULL;
-+	use_cache = (DUK_HSTRING_GET_CHARLEN(h) > DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT);
-+
-+	if (use_cache) {
-+#ifdef DUK_USE_DDDPRINT
-+		DUK_DDD(DUK_DDDPRINT("stringcache before char2byte (using cache):"));
-+		for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-+			duk_strcache *c = heap->strcache + i;
-+			DUK_DDD(DUK_DDDPRINT("  [%ld] -> h=%p, cidx=%ld, bidx=%ld",
-+			                     (long) i, (void *) c->h, (long) c->cidx, (long) c->bidx));
-+		}
-+#endif
-+
-+		for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-+			duk_strcache *c = heap->strcache + i;
-+
-+			if (c->h == h) {
-+				sce = c;
-+				break;
-+			}
-+		}
-+	}
-+
-+	/*
-+	 *  Scan from shortest distance:
-+	 *    - start of string
-+	 *    - end of string
-+	 *    - cache entry (if exists)
-+	 */
-+
-+	DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h) >= char_offset);
-+	dist_start = char_offset;
-+	dist_end = DUK_HSTRING_GET_CHARLEN(h) - char_offset;
-+	dist_sce = 0; DUK_UNREF(dist_sce);  /* initialize for debug prints, needed if sce==NULL */
-+
-+	p_start = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h);
-+	p_end = (duk_uint8_t *) (p_start + DUK_HSTRING_GET_BYTELEN(h));
-+	p_found = NULL;
-+
-+	if (sce) {
-+		if (char_offset >= sce->cidx) {
-+			dist_sce = char_offset - sce->cidx;
-+			if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) {
-+				DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
-+				                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
-+				                     "scan forwards from sce",
-+				                     (long) use_cache, (void *) (sce ? sce->h : NULL),
-+				                     (sce ? (long) sce->cidx : (long) -1),
-+				                     (sce ? (long) sce->bidx : (long) -1),
-+				                     (long) dist_start, (long) dist_end, (long) dist_sce));
-+
-+				p_found = duk__scan_forwards(p_start + sce->bidx,
-+				                             p_end,
-+				                             dist_sce);
-+				goto scan_done;
-+			}
-+		} else {
-+			dist_sce = sce->cidx - char_offset;
-+			if ((dist_sce <= dist_start) && (dist_sce <= dist_end)) {
-+				DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
-+				                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
-+				                     "scan backwards from sce",
-+				                     (long) use_cache, (void *) (sce ? sce->h : NULL),
-+				                     (sce ? (long) sce->cidx : (long) -1),
-+				                     (sce ? (long) sce->bidx : (long) -1),
-+				                     (long) dist_start, (long) dist_end, (long) dist_sce));
-+
-+				p_found = duk__scan_backwards(p_start + sce->bidx,
-+				                              p_start,
-+				                              dist_sce);
-+				goto scan_done;
-+			}
-+		}
-+	}
-+
-+	/* no sce, or sce scan not best */
-+
-+	if (dist_start <= dist_end) {
-+		DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
-+		                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
-+		                     "scan forwards from string start",
-+		                     (long) use_cache, (void *) (sce ? sce->h : NULL),
-+		                     (sce ? (long) sce->cidx : (long) -1),
-+		                     (sce ? (long) sce->bidx : (long) -1),
-+		                     (long) dist_start, (long) dist_end, (long) dist_sce));
-+
-+		p_found = duk__scan_forwards(p_start,
-+		                             p_end,
-+		                             dist_start);
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("non-ascii string, use_cache=%ld, sce=%p:%ld:%ld, "
-+		                     "dist_start=%ld, dist_end=%ld, dist_sce=%ld => "
-+		                     "scan backwards from string end",
-+		                     (long) use_cache, (void *) (sce ? sce->h : NULL),
-+		                     (sce ? (long) sce->cidx : (long) -1),
-+		                     (sce ? (long) sce->bidx : (long) -1),
-+		                     (long) dist_start, (long) dist_end, (long) dist_sce));
-+
-+		p_found = duk__scan_backwards(p_end,
-+		                              p_start,
-+		                              dist_end);
-+	}
-+
-+ scan_done:
-+
-+	if (!p_found) {
-+		/* Scan error: this shouldn't normally happen; it could happen if
-+		 * string is not valid UTF-8 data, and clen/blen are not consistent
-+		 * with the scanning algorithm.
-+		 */
-+		goto error;
-+	}
-+
-+	DUK_ASSERT(p_found >= p_start);
-+	DUK_ASSERT(p_found <= p_end);  /* may be equal */
-+	byte_offset = (duk_uint32_t) (p_found - p_start);
-+
-+	DUK_DDD(DUK_DDDPRINT("-> string %p, cidx %ld -> bidx %ld",
-+	                     (void *) h, (long) char_offset, (long) byte_offset));
-+
-+	/*
-+	 *  Update cache entry (allocating if necessary), and move the
-+	 *  cache entry to the first place (in an "LRU" policy).
-+	 */
-+
-+	if (use_cache) {
-+		/* update entry, allocating if necessary */
-+		if (!sce) {
-+			sce = heap->strcache + DUK_HEAP_STRCACHE_SIZE - 1;  /* take last entry */
-+			sce->h = h;
-+		}
-+		DUK_ASSERT(sce != NULL);
-+		sce->bidx = (duk_uint32_t) (p_found - p_start);
-+		sce->cidx = (duk_uint32_t) char_offset;
-+
-+		/* LRU: move our entry to first */
-+		if (sce > &heap->strcache[0]) {
-+			/*
-+			 *   A                  C
-+			 *   B                  A
-+			 *   C <- sce    ==>    B
-+			 *   D                  D
-+			 */
-+			duk_strcache tmp;
-+
-+			tmp = *sce;
-+			DUK_MEMMOVE((void *) (&heap->strcache[1]),
-+			            (void *) (&heap->strcache[0]),
-+			            (size_t) (((char *) sce) - ((char *) &heap->strcache[0])));
-+			heap->strcache[0] = tmp;
-+
-+			/* 'sce' points to the wrong entry here, but is no longer used */
-+		}
-+#ifdef DUK_USE_DDDPRINT
-+		DUK_DDD(DUK_DDDPRINT("stringcache after char2byte (using cache):"));
-+		for (i = 0; i < DUK_HEAP_STRCACHE_SIZE; i++) {
-+			duk_strcache *c = heap->strcache + i;
-+			DUK_DDD(DUK_DDDPRINT("  [%ld] -> h=%p, cidx=%ld, bidx=%ld",
-+			                     (long) i, (void *) c->h, (long) c->cidx, (long) c->bidx));
-+		}
-+#endif
-+	}
-+
-+	return byte_offset;
-+
-+ error:
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "string scan error");
-+	return 0;
-+}
-+#line 1 "duk_heap_stringtable.c"
-+/*
-+ *  Heap stringtable handling, string interning.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#if defined(DUK_USE_STRTAB_PROBE)
-+#define DUK__HASH_INITIAL(hash,h_size)        DUK_STRTAB_HASH_INITIAL((hash),(h_size))
-+#define DUK__HASH_PROBE_STEP(hash)            DUK_STRTAB_HASH_PROBE_STEP((hash))
-+#define DUK__DELETED_MARKER(heap)             DUK_STRTAB_DELETED_MARKER((heap))
-+#endif
-+
-+/*
-+ *  Create a hstring and insert into the heap.  The created object
-+ *  is directly garbage collectable with reference count zero.
-+ *
-+ *  The caller must place the interned string into the stringtable
-+ *  immediately (without chance of a longjmp); otherwise the string
-+ *  is lost.
-+ */
-+
-+DUK_LOCAL
-+duk_hstring *duk__alloc_init_hstring(duk_heap *heap,
-+                                     const duk_uint8_t *str,
-+                                     duk_uint32_t blen,
-+                                     duk_uint32_t strhash,
-+                                     const duk_uint8_t *extdata) {
-+	duk_hstring *res = NULL;
-+	duk_uint8_t *data;
-+	duk_size_t alloc_size;
-+	duk_uarridx_t dummy;
-+	duk_uint32_t clen;
-+
-+#if defined(DUK_USE_STRLEN16)
-+	/* If blen <= 0xffffUL, clen is also guaranteed to be <= 0xffffUL. */
-+	if (blen > 0xffffUL) {
-+		DUK_D(DUK_DPRINT("16-bit string blen/clen active and blen over 16 bits, reject intern"));
-+		return NULL;
-+	}
-+#endif
-+
-+	if (extdata) {
-+		alloc_size = (duk_size_t) sizeof(duk_hstring_external);
-+		res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
-+		if (!res) {
-+			goto alloc_error;
-+		}
-+		DUK_MEMZERO(res, sizeof(duk_hstring_external));
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+		DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
-+#endif
-+		DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, DUK_HSTRING_FLAG_EXTDATA);
-+
-+		((duk_hstring_external *) res)->extdata = extdata;
-+	} else {
-+		/* NUL terminate for convenient C access */
-+		alloc_size = (duk_size_t) (sizeof(duk_hstring) + blen + 1);
-+		res = (duk_hstring *) DUK_ALLOC(heap, alloc_size);
-+		if (!res) {
-+			goto alloc_error;
-+		}
-+		DUK_MEMZERO(res, sizeof(duk_hstring));
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+		DUK_HEAPHDR_STRING_INIT_NULLS(&res->hdr);
-+#endif
-+		DUK_HEAPHDR_SET_TYPE_AND_FLAGS(&res->hdr, DUK_HTYPE_STRING, 0);
-+
-+		data = (duk_uint8_t *) (res + 1);
-+		DUK_MEMCPY(data, str, blen);
-+		data[blen] = (duk_uint8_t) 0;
-+	}
-+
-+	if (duk_js_to_arrayindex_raw_string(str, blen, &dummy)) {
-+		DUK_HSTRING_SET_ARRIDX(res);
-+	}
-+
-+	/* All strings beginning with 0xff are treated as "internal",
-+	 * even strings interned by the user.  This allows user code to
-+	 * create internal properties too, and makes behavior consistent
-+	 * in case user code happens to use a string also used by Duktape
-+	 * (such as string has already been interned and has the 'internal'
-+	 * flag set).
-+	 */
-+	if (blen > 0 && str[0] == (duk_uint8_t) 0xff) {
-+		DUK_HSTRING_SET_INTERNAL(res);
-+	}
-+
-+	DUK_HSTRING_SET_HASH(res, strhash);
-+	DUK_HSTRING_SET_BYTELEN(res, blen);
-+	clen = (duk_uint32_t) duk_unicode_unvalidated_utf8_length(str, (duk_size_t) blen);
-+	DUK_ASSERT(clen <= blen);
-+	DUK_HSTRING_SET_CHARLEN(res, clen);
-+
-+	DUK_DDD(DUK_DDDPRINT("interned string, hash=0x%08lx, blen=%ld, clen=%ld, has_arridx=%ld, has_extdata=%ld",
-+	                     (unsigned long) DUK_HSTRING_GET_HASH(res),
-+	                     (long) DUK_HSTRING_GET_BYTELEN(res),
-+	                     (long) DUK_HSTRING_GET_CHARLEN(res),
-+	                     (long) DUK_HSTRING_HAS_ARRIDX(res) ? 1 : 0,
-+	                     (long) DUK_HSTRING_HAS_EXTDATA(res) ? 1 : 0));
-+
-+	return res;
-+
-+ alloc_error:
-+	DUK_FREE(heap, res);
-+	return NULL;
-+}
-+
-+/*
-+ *  String table algorithm: fixed size string table with array chaining
-+ *
-+ *  The top level string table has a fixed size, with each slot holding
-+ *  either NULL, string pointer, or pointer to a separately allocated
-+ *  string pointer list.
-+ *
-+ *  This is good for low memory environments using a pool allocator: the
-+ *  top level allocation has a fixed size and the pointer lists have quite
-+ *  small allocation size, which further matches the typical pool sizes
-+ *  needed by objects, strings, property tables, etc.
-+ */
-+
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+DUK_LOCAL duk_bool_t duk__insert_hstring_chain(duk_heap *heap, duk_hstring *h) {
-+	duk_small_uint_t slotidx;
-+	duk_strtab_entry *e;
-+	duk_uint16_t *lst;
-+	duk_uint16_t *new_lst;
-+	duk_size_t i, n;
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+	duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(h != NULL);
-+
-+	slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE;
-+	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-+
-+	e = heap->strtable + slotidx;
-+	if (e->listlen == 0) {
-+		if (e->u.str16 == null16) {
-+			e->u.str16 = h16;
-+		} else {
-+			/* Now two entries in the same slot, alloc list */
-+			lst = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * 2);
-+			if (lst == NULL) {
-+				return 1;  /* fail */
-+			}
-+			lst[0] = e->u.str16;
-+			lst[1] = h16;
-+			e->u.strlist16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) lst);
-+			e->listlen = 2;
-+		}
-+	} else {
-+		DUK_ASSERT(e->u.strlist16 != null16);
-+		lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-+		DUK_ASSERT(lst != NULL);
-+		for (i = 0, n = e->listlen; i < n; i++) {
-+			if (lst[i] == null16) {
-+				lst[i] = h16;
-+				return 0;
-+			}
-+		}
-+
-+		if (e->listlen + 1 == 0) {
-+			/* Overflow, relevant mainly when listlen is 16 bits. */
-+			return 1;  /* fail */
-+		}
-+
-+		new_lst = (duk_uint16_t *) DUK_REALLOC(heap, lst, sizeof(duk_uint16_t) * (e->listlen + 1));
-+		if (new_lst == NULL) {
-+			return 1;  /* fail */
-+		}
-+		new_lst[e->listlen++] = h16;
-+		e->u.strlist16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) new_lst);
-+	}
-+	return 0;
-+}
-+#else  /* DUK_USE_HEAPPTR16 */
-+DUK_LOCAL duk_bool_t duk__insert_hstring_chain(duk_heap *heap, duk_hstring *h) {
-+	duk_small_uint_t slotidx;
-+	duk_strtab_entry *e;
-+	duk_hstring **lst;
-+	duk_hstring **new_lst;
-+	duk_size_t i, n;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(h != NULL);
-+
-+	slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE;
-+	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-+
-+	e = heap->strtable + slotidx;
-+	if (e->listlen == 0) {
-+		if (e->u.str == NULL) {
-+			e->u.str = h;
-+		} else {
-+			/* Now two entries in the same slot, alloc list */
-+			lst = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * 2);
-+			if (lst == NULL) {
-+				return 1;  /* fail */
-+			}
-+			lst[0] = e->u.str;
-+			lst[1] = h;
-+			e->u.strlist = lst;
-+			e->listlen = 2;
-+		}
-+	} else {
-+		DUK_ASSERT(e->u.strlist != NULL);
-+		lst = e->u.strlist;
-+		for (i = 0, n = e->listlen; i < n; i++) {
-+			if (lst[i] == NULL) {
-+				lst[i] = h;
-+				return 0;
-+			}
-+		}
-+
-+		if (e->listlen + 1 == 0) {
-+			/* Overflow, relevant mainly when listlen is 16 bits. */
-+			return 1;  /* fail */
-+		}
-+
-+		new_lst = (duk_hstring **) DUK_REALLOC(heap, e->u.strlist, sizeof(duk_hstring *) * (e->listlen + 1));
-+		if (new_lst == NULL) {
-+			return 1;  /* fail */
-+		}
-+		new_lst[e->listlen++] = h;
-+		e->u.strlist = new_lst;
-+	}
-+	return 0;
-+}
-+#endif  /* DUK_USE_HEAPPTR16 */
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-+	duk_small_uint_t slotidx;
-+	duk_strtab_entry *e;
-+	duk_uint16_t *lst;
-+	duk_size_t i, n;
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+
-+	DUK_ASSERT(heap != NULL);
-+
-+	slotidx = strhash % DUK_STRTAB_CHAIN_SIZE;
-+	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-+
-+	e = heap->strtable + slotidx;
-+	if (e->listlen == 0) {
-+		if (e->u.str16 != null16) {
-+			duk_hstring *h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16);
-+			DUK_ASSERT(h != NULL);
-+			if (DUK_HSTRING_GET_BYTELEN(h) == blen &&
-+			    DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(h), blen) == 0) {
-+				return h;
-+			}
-+		}
-+	} else {
-+		DUK_ASSERT(e->u.strlist16 != null16);
-+		lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-+		DUK_ASSERT(lst != NULL);
-+		for (i = 0, n = e->listlen; i < n; i++) {
-+			if (lst[i] != null16) {
-+				duk_hstring *h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[i]);
-+				DUK_ASSERT(h != NULL);
-+				if (DUK_HSTRING_GET_BYTELEN(h) == blen &&
-+				    DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(h), blen) == 0) {
-+					return h;
-+				}
-+			}
-+		}
-+	}
-+
-+	return NULL;
-+}
-+#else  /* DUK_USE_HEAPPTR16 */
-+DUK_LOCAL duk_hstring *duk__find_matching_string_chain(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-+	duk_small_uint_t slotidx;
-+	duk_strtab_entry *e;
-+	duk_hstring **lst;
-+	duk_size_t i, n;
-+
-+	DUK_ASSERT(heap != NULL);
-+
-+	slotidx = strhash % DUK_STRTAB_CHAIN_SIZE;
-+	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-+
-+	e = heap->strtable + slotidx;
-+	if (e->listlen == 0) {
-+		if (e->u.str != NULL &&
-+	           DUK_HSTRING_GET_BYTELEN(e->u.str) == blen &&
-+	           DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(e->u.str), blen) == 0) {
-+			return e->u.str;
-+		}
-+	} else {
-+		DUK_ASSERT(e->u.strlist != NULL);
-+		lst = e->u.strlist;
-+		for (i = 0, n = e->listlen; i < n; i++) {
-+			if (lst[i] != NULL &&
-+		           DUK_HSTRING_GET_BYTELEN(lst[i]) == blen &&
-+		           DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(lst[i]), blen) == 0) {
-+				return lst[i];
-+			}
-+		}
-+	}
-+
-+	return NULL;
-+}
-+#endif  /* DUK_USE_HEAPPTR16 */
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+DUK_LOCAL void duk__remove_matching_hstring_chain(duk_heap *heap, duk_hstring *h) {
-+	duk_small_uint_t slotidx;
-+	duk_strtab_entry *e;
-+	duk_uint16_t *lst;
-+	duk_size_t i, n;
-+	duk_uint16_t h16;
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(h != NULL);
-+
-+	slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE;
-+	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-+
-+	DUK_ASSERT(h != NULL);
-+	h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-+
-+	e = heap->strtable + slotidx;
-+	if (e->listlen == 0) {
-+		if (e->u.str16 == h16) {
-+			e->u.str16 = null16;
-+			return;
-+		}
-+	} else {
-+		DUK_ASSERT(e->u.strlist16 != null16);
-+		lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-+		DUK_ASSERT(lst != NULL);
-+		for (i = 0, n = e->listlen; i < n; i++) {
-+			if (lst[i] == h16) {
-+				lst[i] = null16;
-+				return;
-+			}
-+		}
-+	}
-+
-+	DUK_D(DUK_DPRINT("failed to find string that should be in stringtable"));
-+	DUK_UNREACHABLE();
-+	return;
-+}
-+#else  /* DUK_USE_HEAPPTR16 */
-+DUK_LOCAL void duk__remove_matching_hstring_chain(duk_heap *heap, duk_hstring *h) {
-+	duk_small_uint_t slotidx;
-+	duk_strtab_entry *e;
-+	duk_hstring **lst;
-+	duk_size_t i, n;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(h != NULL);
-+
-+	slotidx = DUK_HSTRING_GET_HASH(h) % DUK_STRTAB_CHAIN_SIZE;
-+	DUK_ASSERT(slotidx < DUK_STRTAB_CHAIN_SIZE);
-+
-+	e = heap->strtable + slotidx;
-+	if (e->listlen == 0) {
-+		DUK_ASSERT(h != NULL);
-+		if (e->u.str == h) {
-+			e->u.str = NULL;
-+			return;
-+		}
-+	} else {
-+		DUK_ASSERT(e->u.strlist != NULL);
-+		lst = e->u.strlist;
-+		for (i = 0, n = e->listlen; i < n; i++) {
-+			DUK_ASSERT(h != NULL);
-+			if (lst[i] == h) {
-+				lst[i] = NULL;
-+				return;
-+			}
-+		}
-+	}
-+
-+	DUK_D(DUK_DPRINT("failed to find string that should be in stringtable"));
-+	DUK_UNREACHABLE();
-+	return;
-+}
-+#endif  /* DUK_USE_HEAPPTR16 */
-+
-+#if defined(DUK_USE_DEBUG)
-+DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap) {
-+	duk_strtab_entry *e;
-+	duk_small_uint_t i;
-+	duk_size_t j, n, used;
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t *lst;
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+#else
-+	duk_hstring **lst;
-+#endif
-+
-+	DUK_ASSERT(heap != NULL);
-+
-+	for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
-+		e = heap->strtable + i;
-+
-+		if (e->listlen == 0) {
-+#if defined(DUK_USE_HEAPPTR16)
-+			DUK_DD(DUK_DDPRINT("[%03d] -> plain %d", (int) i, (int) (e->u.str16 != null16 ? 1 : 0)));
-+#else
-+			DUK_DD(DUK_DDPRINT("[%03d] -> plain %d", (int) i, (int) (e->u.str ? 1 : 0)));
-+#endif
-+		} else {
-+			used = 0;
-+#if defined(DUK_USE_HEAPPTR16)
-+			lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-+#else
-+			lst = e->u.strlist;
-+#endif
-+			DUK_ASSERT(lst != NULL);
-+			for (j = 0, n = e->listlen; j < n; j++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+				if (lst[j] != null16) {
-+#else
-+				if (lst[j] != NULL) {
-+#endif
-+					used++;
-+				}
-+			}
-+			DUK_DD(DUK_DDPRINT("[%03d] -> array %d/%d", (int) i, (int) used, (int) e->listlen));
-+		}
-+	}
-+}
-+#endif  /* DUK_USE_DEBUG */
-+
-+#endif  /* DUK_USE_STRTAB_CHAIN */
-+
-+/*
-+ *  String table algorithm: closed hashing with a probe sequence
-+ *
-+ *  This is the default algorithm and works fine for environments with
-+ *  minimal memory constraints.
-+ */
-+
-+#if defined(DUK_USE_STRTAB_PROBE)
-+
-+/* Count actually used (non-NULL, non-DELETED) entries. */
-+DUK_LOCAL duk_int_t duk__count_used_probe(duk_heap *heap) {
-+	duk_int_t res = 0;
-+	duk_uint_fast32_t i, n;
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+	duk_uint16_t deleted16 = heap->heapptr_deleted16;
-+#endif
-+
-+	n = (duk_uint_fast32_t) heap->st_size;
-+	for (i = 0; i < n; i++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+		if (heap->strtable16[i] != null16 && heap->strtable16[i] != deleted16) {
-+#else
-+		if (heap->strtable[i] != NULL && heap->strtable[i] != DUK__DELETED_MARKER(heap)) {
-+#endif
-+			res++;
-+		}
-+	}
-+	return res;
-+}
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) {
-+#else
-+DUK_LOCAL void duk__insert_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_uint32_t *p_used, duk_hstring *h) {
-+#endif
-+	duk_uint32_t i;
-+	duk_uint32_t step;
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+	duk_uint16_t deleted16 = heap->heapptr_deleted16;
-+#endif
-+
-+	DUK_ASSERT(size > 0);
-+
-+	i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size);
-+	step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(h));
-+	for (;;) {
-+#if defined(DUK_USE_HEAPPTR16)
-+		duk_uint16_t e16 = entries16[i];
-+#else
-+		duk_hstring *e = entries[i];
-+#endif
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+		/* XXX: could check for e16 == 0 because NULL is guaranteed to
-+		 * encode to zero.
-+		 */
-+		if (e16 == null16) {
-+#else
-+		if (e == NULL) {
-+#endif
-+			DUK_DDD(DUK_DDDPRINT("insert hit (null): %ld", (long) i));
-+#if defined(DUK_USE_HEAPPTR16)
-+			entries16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-+#else
-+			entries[i] = h;
-+#endif
-+			(*p_used)++;
-+			break;
-+#if defined(DUK_USE_HEAPPTR16)
-+		} else if (e16 == deleted16) {
-+#else
-+		} else if (e == DUK__DELETED_MARKER(heap)) {
-+#endif
-+			/* st_used remains the same, DELETED is counted as used */
-+			DUK_DDD(DUK_DDDPRINT("insert hit (deleted): %ld", (long) i));
-+#if defined(DUK_USE_HEAPPTR16)
-+			entries16[i] = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-+#else
-+			entries[i] = h;
-+#endif
-+			break;
-+		}
-+		DUK_DDD(DUK_DDDPRINT("insert miss: %ld", (long) i));
-+		i = (i + step) % size;
-+
-+		/* looping should never happen */
-+		DUK_ASSERT(i != DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(h), size));
-+	}
-+}
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-+#else
-+DUK_LOCAL duk_hstring *duk__find_matching_string_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-+#endif
-+	duk_uint32_t i;
-+	duk_uint32_t step;
-+
-+	DUK_ASSERT(size > 0);
-+
-+	i = DUK__HASH_INITIAL(strhash, size);
-+	step = DUK__HASH_PROBE_STEP(strhash);
-+	for (;;) {
-+		duk_hstring *e;
-+#if defined(DUK_USE_HEAPPTR16)
-+		e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, entries16[i]);
-+#else
-+		e = entries[i];
-+#endif
-+
-+		if (!e) {
-+			return NULL;
-+		}
-+		if (e != DUK__DELETED_MARKER(heap) && DUK_HSTRING_GET_BYTELEN(e) == blen) {
-+			if (DUK_MEMCMP(str, DUK_HSTRING_GET_DATA(e), blen) == 0) {
-+				DUK_DDD(DUK_DDDPRINT("find matching hit: %ld (step %ld, size %ld)",
-+				                     (long) i, (long) step, (long) size));
-+				return e;
-+			}
-+		}
-+		DUK_DDD(DUK_DDDPRINT("find matching miss: %ld (step %ld, size %ld)",
-+		                     (long) i, (long) step, (long) size));
-+		i = (i + step) % size;
-+
-+		/* looping should never happen */
-+		DUK_ASSERT(i != DUK__HASH_INITIAL(strhash, size));
-+	}
-+	DUK_UNREACHABLE();
-+}
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_uint16_t *entries16, duk_uint32_t size, duk_hstring *h) {
-+#else
-+DUK_LOCAL void duk__remove_matching_hstring_probe(duk_heap *heap, duk_hstring **entries, duk_uint32_t size, duk_hstring *h) {
-+#endif
-+	duk_uint32_t i;
-+	duk_uint32_t step;
-+	duk_uint32_t hash;
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+	duk_uint16_t h16 = DUK_USE_HEAPPTR_ENC16(heap->heap_udata, (void *) h);
-+#endif
-+
-+	DUK_ASSERT(size > 0);
-+
-+	hash = DUK_HSTRING_GET_HASH(h);
-+	i = DUK__HASH_INITIAL(hash, size);
-+	step = DUK__HASH_PROBE_STEP(hash);
-+	for (;;) {
-+#if defined(DUK_USE_HEAPPTR16)
-+		duk_uint16_t e16 = entries16[i];
-+#else
-+		duk_hstring *e = entries[i];
-+#endif
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+		if (e16 == null16) {
-+#else
-+		if (!e) {
-+#endif
-+			DUK_UNREACHABLE();
-+			break;
-+		}
-+#if defined(DUK_USE_HEAPPTR16)
-+		if (e16 == h16) {
-+#else
-+		if (e == h) {
-+#endif
-+			/* st_used remains the same, DELETED is counted as used */
-+			DUK_DDD(DUK_DDDPRINT("free matching hit: %ld", (long) i));
-+#if defined(DUK_USE_HEAPPTR16)
-+			entries16[i] = heap->heapptr_deleted16;
-+#else
-+			entries[i] = DUK__DELETED_MARKER(heap);
-+#endif
-+			break;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("free matching miss: %ld", (long) i));
-+		i = (i + step) % size;
-+
-+		/* looping should never happen */
-+		DUK_ASSERT(i != DUK__HASH_INITIAL(hash, size));
-+	}
-+}
-+
-+DUK_LOCAL duk_bool_t duk__resize_strtab_raw_probe(duk_heap *heap, duk_uint32_t new_size) {
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	duk_small_uint_t prev_mark_and_sweep_base_flags;
-+#endif
-+#ifdef DUK_USE_DEBUG
-+	duk_uint32_t old_used = heap->st_used;
-+#endif
-+	duk_uint32_t old_size = heap->st_size;
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t *old_entries = heap->strtable16;
-+	duk_uint16_t *new_entries = NULL;
-+#else
-+	duk_hstring **old_entries = heap->strtable;
-+	duk_hstring **new_entries = NULL;
-+#endif
-+	duk_uint32_t new_used = 0;
-+	duk_uint32_t i;
-+
-+#ifdef DUK_USE_DEBUG
-+	DUK_UNREF(old_used);  /* unused with some debug level combinations */
-+#endif
-+
-+#ifdef DUK_USE_DDDPRINT
-+	DUK_DDD(DUK_DDDPRINT("attempt to resize stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
-+	                     (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
-+	                     (long) (((double) old_used) / ((double) old_size) * 100.0),
-+	                     (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) duk__count_used_probe(heap),
-+	                     (long) (((double) duk__count_used_probe(heap)) / ((double) new_size) * 100.0)));
-+#endif
-+
-+	DUK_ASSERT(new_size > (duk_uint32_t) duk__count_used_probe(heap));  /* required for rehash to succeed, equality not that useful */
-+	DUK_ASSERT(old_entries);
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	DUK_ASSERT((heap->mark_and_sweep_base_flags & DUK_MS_FLAG_NO_STRINGTABLE_RESIZE) == 0);
-+#endif
-+
-+	/*
-+	 *  The attempt to allocate may cause a GC.  Such a GC must not attempt to resize
-+	 *  the stringtable (though it can be swept); finalizer execution and object
-+	 *  compaction must also be postponed to avoid the pressure to add strings to the
-+	 *  string table.
-+	 */
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	prev_mark_and_sweep_base_flags = heap->mark_and_sweep_base_flags;
-+	heap->mark_and_sweep_base_flags |= \
-+	        DUK_MS_FLAG_NO_STRINGTABLE_RESIZE |  /* avoid recursive call here */
-+	        DUK_MS_FLAG_NO_FINALIZERS |          /* avoid pressure to add/remove strings */
-+	        DUK_MS_FLAG_NO_OBJECT_COMPACTION;    /* avoid array abandoning which interns strings */
-+#endif
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+	new_entries = (duk_uint16_t *) DUK_ALLOC(heap, sizeof(duk_uint16_t) * new_size);
-+#else
-+	new_entries = (duk_hstring **) DUK_ALLOC(heap, sizeof(duk_hstring *) * new_size);
-+#endif
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
-+#endif
-+
-+	if (!new_entries) {
-+		goto resize_error;
-+	}
-+
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	for (i = 0; i < new_size; i++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+		new_entries[i] = heap->heapptr_null16;
-+#else
-+		new_entries[i] = NULL;
-+#endif
-+	}
-+#else
-+#if defined(DUK_USE_HEAPPTR16)
-+	/* Relies on NULL encoding to zero. */
-+	DUK_MEMZERO(new_entries, sizeof(duk_uint16_t) * new_size);
-+#else
-+	DUK_MEMZERO(new_entries, sizeof(duk_hstring *) * new_size);
-+#endif
-+#endif
-+
-+	/* Because new_size > duk__count_used_probe(heap), guaranteed to work */
-+	for (i = 0; i < old_size; i++) {
-+		duk_hstring *e;
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+		e = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, old_entries[i]);
-+#else
-+		e = old_entries[i];
-+#endif
-+		if (e == NULL || e == DUK__DELETED_MARKER(heap)) {
-+			continue;
-+		}
-+		/* checking for DUK__DELETED_MARKER is not necessary here, but helper does it now */
-+		duk__insert_hstring_probe(heap, new_entries, new_size, &new_used, e);
-+	}
-+
-+#ifdef DUK_USE_DDPRINT
-+	DUK_DD(DUK_DDPRINT("resized stringtable: %ld entries, %ld bytes, %ld used, %ld%% load -> %ld entries, %ld bytes, %ld used, %ld%% load",
-+	                   (long) old_size, (long) (sizeof(duk_hstring *) * old_size), (long) old_used,
-+	                   (long) (((double) old_used) / ((double) old_size) * 100.0),
-+	                   (long) new_size, (long) (sizeof(duk_hstring *) * new_size), (long) new_used,
-+	                   (long) (((double) new_used) / ((double) new_size) * 100.0)));
-+#endif
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+	DUK_FREE(heap, heap->strtable16);
-+	heap->strtable16 = new_entries;
-+#else
-+	DUK_FREE(heap, heap->strtable);
-+	heap->strtable = new_entries;
-+#endif
-+	heap->st_size = new_size;
-+	heap->st_used = new_used;  /* may be less, since DELETED entries are NULLed by rehash */
-+
-+	return 0;  /* OK */
-+
-+ resize_error:
-+	DUK_FREE(heap, new_entries);
-+	return 1;  /* FAIL */
-+}
-+
-+DUK_LOCAL duk_bool_t duk__resize_strtab_probe(duk_heap *heap) {
-+	duk_uint32_t new_size;
-+	duk_bool_t ret;
-+
-+	new_size = (duk_uint32_t) duk__count_used_probe(heap);
-+	if (new_size >= 0x80000000UL) {
-+		new_size = DUK_STRTAB_HIGHEST_32BIT_PRIME;
-+	} else {
-+		new_size = duk_util_get_hash_prime(DUK_STRTAB_GROW_ST_SIZE(new_size));
-+		new_size = duk_util_get_hash_prime(new_size);
-+	}
-+	DUK_ASSERT(new_size > 0);
-+
-+	/* rehash even if old and new sizes are the same to get rid of
-+	 * DELETED entries.
-+	*/
-+
-+	ret = duk__resize_strtab_raw_probe(heap, new_size);
-+
-+	return ret;
-+}
-+
-+DUK_LOCAL duk_bool_t duk__recheck_strtab_size_probe(duk_heap *heap, duk_uint32_t new_used) {
-+	duk_uint32_t new_free;
-+	duk_uint32_t tmp1;
-+	duk_uint32_t tmp2;
-+
-+	DUK_ASSERT(new_used <= heap->st_size);  /* grow by at most one */
-+	new_free = heap->st_size - new_used;    /* unsigned intentionally */
-+
-+	/* new_free / size <= 1 / DIV  <=>  new_free <= size / DIV */
-+	/* new_used / size <= 1 / DIV  <=>  new_used <= size / DIV */
-+
-+	tmp1 = heap->st_size / DUK_STRTAB_MIN_FREE_DIVISOR;
-+	tmp2 = heap->st_size / DUK_STRTAB_MIN_USED_DIVISOR;
-+
-+	if (new_free <= tmp1 || new_used <= tmp2) {
-+		/* load factor too low or high, count actually used entries and resize */
-+		return duk__resize_strtab_probe(heap);
-+	} else {
-+		return 0;  /* OK */
-+	}
-+}
-+
-+#if defined(DUK_USE_DEBUG)
-+DUK_INTERNAL void duk_heap_dump_strtab(duk_heap *heap) {
-+	duk_uint32_t i;
-+	duk_hstring *h;
-+
-+	DUK_ASSERT(heap != NULL);
-+#if defined(DUK_USE_HEAPPTR16)
-+	DUK_ASSERT(heap->strtable16 != NULL);
-+#else
-+	DUK_ASSERT(heap->strtable != NULL);
-+#endif
-+	DUK_UNREF(h);
-+
-+	for (i = 0; i < heap->st_size; i++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+		h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->strtable16[i]);
-+#else
-+		h = heap->strtable[i];
-+#endif
-+
-+		DUK_DD(DUK_DDPRINT("[%03d] -> %p", (int) i, (void *) h));
-+	}
-+}
-+#endif  /* DUK_USE_DEBUG */
-+
-+#endif  /* DUK_USE_STRTAB_PROBE */
-+
-+/*
-+ *  Raw intern and lookup
-+ */
-+
-+DUK_LOCAL duk_hstring *duk__do_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t strhash) {
-+	duk_hstring *res;
-+	const duk_uint8_t *extdata;
-+
-+#if defined(DUK_USE_STRTAB_PROBE)
-+	if (duk__recheck_strtab_size_probe(heap, heap->st_used + 1)) {
-+		return NULL;
-+	}
-+#endif
-+
-+	/* For manual testing only. */
-+#if 0
-+	{
-+		duk_size_t i;
-+		DUK_PRINTF("INTERN: \"");
-+		for (i = 0; i < blen; i++) {
-+			duk_uint8_t x = str[i];
-+			if (x >= 0x20 && x <= 0x7e && x != '"' && x != '\\') {
-+				DUK_PRINTF("%c", (int) x);  /* char: use int cast */
-+			} else {
-+				DUK_PRINTF("\\x%02lx", (long) x);
-+			}
-+		}
-+		DUK_PRINTF("\"\n");
-+	}
-+#endif
-+
-+#if defined(DUK_USE_HSTRING_EXTDATA) && defined(DUK_USE_EXTSTR_INTERN_CHECK)
-+	extdata = (const duk_uint8_t *) DUK_USE_EXTSTR_INTERN_CHECK(heap->heap_udata, (void *) str, (duk_size_t) blen);
-+#else
-+	extdata = (const duk_uint8_t *) NULL;
-+#endif
-+	res = duk__alloc_init_hstring(heap, str, blen, strhash, extdata);
-+	if (!res) {
-+		return NULL;
-+	}
-+
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	if (duk__insert_hstring_chain(heap, res)) {
-+		/* failed */
-+		DUK_FREE(heap, res);
-+		return NULL;
-+	}
-+#elif defined(DUK_USE_STRTAB_PROBE)
-+	/* guaranteed to succeed */
-+	duk__insert_hstring_probe(heap,
-+#if defined(DUK_USE_HEAPPTR16)
-+	                          heap->strtable16,
-+#else
-+	                          heap->strtable,
-+#endif
-+	                          heap->st_size,
-+	                          &heap->st_used,
-+	                          res);
-+#else
-+#error internal error, invalid strtab options
-+#endif
-+
-+	/* Note: hstring is in heap but has refcount zero and is not strongly reachable.
-+	 * Caller should increase refcount and make the hstring reachable before any
-+	 * operations which require allocation (and possible gc).
-+	 */
-+
-+	return res;
-+}
-+
-+DUK_LOCAL duk_hstring *duk__do_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen, duk_uint32_t *out_strhash) {
-+	duk_hstring *res;
-+
-+	DUK_ASSERT(out_strhash);
-+
-+	*out_strhash = duk_heap_hashstring(heap, str, (duk_size_t) blen);
-+
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	res = duk__find_matching_string_chain(heap, str, blen, *out_strhash);
-+#elif defined(DUK_USE_STRTAB_PROBE)
-+	res = duk__find_matching_string_probe(heap,
-+#if defined(DUK_USE_HEAPPTR16)
-+	                                      heap->strtable16,
-+#else
-+	                                      heap->strtable,
-+#endif
-+	                                      heap->st_size,
-+	                                      str,
-+	                                      blen,
-+	                                      *out_strhash);
-+#else
-+#error internal error, invalid strtab options
-+#endif
-+
-+	return res;
-+}
-+
-+/*
-+ *  Exposed calls
-+ */
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL duk_hstring *duk_heap_string_lookup(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen) {
-+	duk_uint32_t strhash;  /* dummy */
-+	return duk__do_lookup(heap, str, blen, &strhash);
-+}
-+#endif
-+
-+DUK_INTERNAL duk_hstring *duk_heap_string_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen) {
-+	duk_hstring *res;
-+	duk_uint32_t strhash;
-+
-+	/* caller is responsible for ensuring this */
-+	DUK_ASSERT(blen <= DUK_HSTRING_MAX_BYTELEN);
-+
-+	res = duk__do_lookup(heap, str, blen, &strhash);
-+	if (res) {
-+		return res;
-+	}
-+
-+	res = duk__do_intern(heap, str, blen, strhash);
-+	return res;  /* may be NULL */
-+}
-+
-+DUK_INTERNAL duk_hstring *duk_heap_string_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t blen) {
-+	duk_hstring *res = duk_heap_string_intern(thr->heap, str, blen);
-+	if (!res) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "failed to intern string");
-+	}
-+	return res;
-+}
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL duk_hstring *duk_heap_string_lookup_u32(duk_heap *heap, duk_uint32_t val) {
-+	char buf[DUK_STRTAB_U32_MAX_STRLEN+1];
-+	DUK_SNPRINTF(buf, sizeof(buf), "%lu", (unsigned long) val);
-+	buf[sizeof(buf) - 1] = (char) 0;
-+	DUK_ASSERT(DUK_STRLEN(buf) <= DUK_UINT32_MAX);  /* formatted result limited */
-+	return duk_heap_string_lookup(heap, (const duk_uint8_t *) buf, (duk_uint32_t) DUK_STRLEN(buf));
-+}
-+#endif
-+
-+DUK_INTERNAL duk_hstring *duk_heap_string_intern_u32(duk_heap *heap, duk_uint32_t val) {
-+	char buf[DUK_STRTAB_U32_MAX_STRLEN+1];
-+	DUK_SNPRINTF(buf, sizeof(buf), "%lu", (unsigned long) val);
-+	buf[sizeof(buf) - 1] = (char) 0;
-+	DUK_ASSERT(DUK_STRLEN(buf) <= DUK_UINT32_MAX);  /* formatted result limited */
-+	return duk_heap_string_intern(heap, (const duk_uint8_t *) buf, (duk_uint32_t) DUK_STRLEN(buf));
-+}
-+
-+DUK_INTERNAL duk_hstring *duk_heap_string_intern_u32_checked(duk_hthread *thr, duk_uint32_t val) {
-+	duk_hstring *res = duk_heap_string_intern_u32(thr->heap, val);
-+	if (!res) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "failed to intern string");
-+	}
-+	return res;
-+}
-+
-+/* find and remove string from stringtable; caller must free the string itself */
-+DUK_INTERNAL void duk_heap_string_remove(duk_heap *heap, duk_hstring *h) {
-+	DUK_DDD(DUK_DDDPRINT("remove string from stringtable: %!O", (duk_heaphdr *) h));
-+
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	duk__remove_matching_hstring_chain(heap, h);
-+#elif defined(DUK_USE_STRTAB_PROBE)
-+	duk__remove_matching_hstring_probe(heap,
-+#if defined(DUK_USE_HEAPPTR16)
-+	                                   heap->strtable16,
-+#else
-+	                                   heap->strtable,
-+#endif
-+	                                   heap->st_size,
-+	                                   h);
-+#else
-+#error internal error, invalid strtab options
-+#endif
-+}
-+
-+#if defined(DUK_USE_MARK_AND_SWEEP) && defined(DUK_USE_MS_STRINGTABLE_RESIZE)
-+DUK_INTERNAL void duk_heap_force_strtab_resize(duk_heap *heap) {
-+	/* Force a resize so that DELETED entries are eliminated.
-+	 * Another option would be duk__recheck_strtab_size_probe();
-+	 * but since that happens on every intern anyway, this whole
-+	 * check can now be disabled.
-+	 */
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+	DUK_UNREF(heap);
-+#elif defined(DUK_USE_STRTAB_PROBE)
-+	duk__resize_strtab_probe(heap);
-+#endif
-+}
-+#endif
-+
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) {
-+	/* Free strings in the stringtable and any allocations needed
-+	 * by the stringtable itself.
-+	 */
-+	duk_uint_fast32_t i, j;
-+	duk_strtab_entry *e;
-+#if defined(DUK_USE_HEAPPTR16)
-+	duk_uint16_t *lst;
-+	duk_uint16_t null16 = heap->heapptr_null16;
-+#else
-+	duk_hstring **lst;
-+#endif
-+	duk_hstring *h;
-+
-+	for (i = 0; i < DUK_STRTAB_CHAIN_SIZE; i++) {
-+		e = heap->strtable + i;
-+		if (e->listlen > 0) {
-+#if defined(DUK_USE_HEAPPTR16)
-+			lst = (duk_uint16_t *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.strlist16);
-+#else
-+			lst = e->u.strlist;
-+#endif
-+			DUK_ASSERT(lst != NULL);
-+
-+			for (j = 0; j < e->listlen; j++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+				h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, lst[j]);
-+				lst[j] = null16;
-+#else
-+				h = lst[j];
-+				lst[j] = NULL;
-+#endif
-+				/* strings may have inner refs (extdata) in some cases */
-+				if (h != NULL) {
-+					duk_free_hstring_inner(heap, h);
-+					DUK_FREE(heap, h);
-+				}
-+			}
-+#if defined(DUK_USE_HEAPPTR16)
-+			e->u.strlist16 = null16;
-+#else
-+			e->u.strlist = NULL;
-+#endif
-+			DUK_FREE(heap, lst);
-+		} else {
-+#if defined(DUK_USE_HEAPPTR16)
-+			h = DUK_USE_HEAPPTR_DEC16(heap->heap_udata, e->u.str16);
-+			e->u.str16 = null16;
-+#else
-+			h = e->u.str;
-+			e->u.str = NULL;
-+#endif
-+			if (h != NULL) {
-+				duk_free_hstring_inner(heap, h);
-+				DUK_FREE(heap, h);
-+			}
-+		}
-+		e->listlen = 0;
-+	}
-+}
-+#endif  /* DUK_USE_STRTAB_CHAIN */
-+
-+#if defined(DUK_USE_STRTAB_PROBE)
-+DUK_INTERNAL void duk_heap_free_strtab(duk_heap *heap) {
-+	duk_uint_fast32_t i;
-+	duk_hstring *h;
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+	if (heap->strtable16) {
-+#else
-+	if (heap->strtable) {
-+#endif
-+		for (i = 0; i < (duk_uint_fast32_t) heap->st_size; i++) {
-+#if defined(DUK_USE_HEAPPTR16)
-+			h = (duk_hstring *) DUK_USE_HEAPPTR_DEC16(heap->heap_udata, heap->strtable16[i]);
-+#else
-+			h = heap->strtable[i];
-+#endif
-+			if (h == NULL || h == DUK_STRTAB_DELETED_MARKER(heap)) {
-+				continue;
-+			}
-+			DUK_ASSERT(h != NULL);
-+
-+			/* strings may have inner refs (extdata) in some cases */
-+			duk_free_hstring_inner(heap, h);
-+			DUK_FREE(heap, h);
-+#if 0  /* not strictly necessary */
-+			heap->strtable[i] = NULL;
-+#endif
-+		}
-+#if defined(DUK_USE_HEAPPTR16)
-+		DUK_FREE(heap, heap->strtable16);
-+#else
-+		DUK_FREE(heap, heap->strtable);
-+#endif
-+#if 0  /* not strictly necessary */
-+		heap->strtable = NULL;
-+#endif
-+	}
-+}
-+#endif  /* DUK_USE_STRTAB_PROBE */
-+
-+/* Undefine local defines */
-+#undef DUK__HASH_INITIAL
-+#undef DUK__HASH_PROBE_STEP
-+#undef DUK__DELETED_MARKER
-+#line 1 "duk_hobject_alloc.c"
-+/*
-+ *  Hobject allocation.
-+ *
-+ *  Provides primitive allocation functions for all object types (plain object,
-+ *  compiled function, native function, thread).  The object return is not yet
-+ *  in "heap allocated" list and has a refcount of zero, so caller must careful.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_LOCAL void duk__init_object_parts(duk_heap *heap, duk_hobject *obj, duk_uint_t hobject_flags) {
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	DUK_HOBJECT_SET_PROPS(heap, obj, NULL);
-+#endif
-+
-+	/* XXX: macro? sets both heaphdr and object flags */
-+	obj->hdr.h_flags = hobject_flags;
-+	DUK_HEAPHDR_SET_TYPE(&obj->hdr, DUK_HTYPE_OBJECT);  /* also goes into flags */
-+
-+#if defined(DUK_USE_HEAPPTR16)
-+	/* Zero encoded pointer is required to match NULL */
-+	DUK_HEAPHDR_SET_NEXT(heap, &obj->hdr, NULL);
-+#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
-+	DUK_HEAPHDR_SET_PREV(heap, &obj->hdr, NULL);
-+#endif
-+#endif
-+        DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, &obj->hdr);
-+
-+	/*
-+	 *  obj->props is intentionally left as NULL, and duk_hobject_props.c must deal
-+	 *  with this properly.  This is intentional: empty objects consume a minimum
-+	 *  amount of memory.  Further, an initial allocation might fail and cause
-+	 *  'obj' to "leak" (require a mark-and-sweep) since it is not reachable yet.
-+	 */
-+}
-+
-+/*
-+ *  Allocate an duk_hobject.
-+ *
-+ *  The allocated object has no allocation for properties; the caller may
-+ *  want to force a resize if a desired size is known.
-+ *
-+ *  The allocated object has zero reference count and is not reachable.
-+ *  The caller MUST make the object reachable and increase its reference
-+ *  count before invoking any operation that might require memory allocation.
-+ */
-+
-+DUK_INTERNAL duk_hobject *duk_hobject_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
-+	duk_hobject *res;
-+
-+	DUK_ASSERT(heap != NULL);
-+
-+	/* different memory layout, alloc size, and init */
-+	DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_COMPILEDFUNCTION) == 0);
-+	DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_NATIVEFUNCTION) == 0);
-+	DUK_ASSERT((hobject_flags & DUK_HOBJECT_FLAG_THREAD) == 0);
-+
-+	res = (duk_hobject *) DUK_ALLOC(heap, sizeof(duk_hobject));
-+	if (!res) {
-+		return NULL;
-+	}
-+	DUK_MEMZERO(res, sizeof(duk_hobject));
-+
-+	duk__init_object_parts(heap, res, hobject_flags);
-+
-+	return res;
-+}
-+
-+DUK_INTERNAL duk_hcompiledfunction *duk_hcompiledfunction_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
-+	duk_hcompiledfunction *res;
-+
-+	res = (duk_hcompiledfunction *) DUK_ALLOC(heap, sizeof(duk_hcompiledfunction));
-+	if (!res) {
-+		return NULL;
-+	}
-+	DUK_MEMZERO(res, sizeof(duk_hcompiledfunction));
-+
-+	duk__init_object_parts(heap, &res->obj, hobject_flags);
-+
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+#ifdef DUK_USE_HEAPPTR16
-+	/* NULL pointer is required to encode to zero, so memset is enough. */
-+#else
-+	res->data = NULL;
-+	res->funcs = NULL;
-+	res->bytecode = NULL;
-+#endif
-+#endif
-+
-+	return res;
-+}
-+
-+DUK_INTERNAL duk_hnativefunction *duk_hnativefunction_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
-+	duk_hnativefunction *res;
-+
-+	res = (duk_hnativefunction *) DUK_ALLOC(heap, sizeof(duk_hnativefunction));
-+	if (!res) {
-+		return NULL;
-+	}
-+	DUK_MEMZERO(res, sizeof(duk_hnativefunction));
-+
-+	duk__init_object_parts(heap, &res->obj, hobject_flags);
-+
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	res->func = NULL;
-+#endif
-+
-+	return res;
-+}
-+
-+/*
-+ *  Allocate a new thread.
-+ *
-+ *  Leaves the built-ins array uninitialized.  The caller must either
-+ *  initialize a new global context or share existing built-ins from
-+ *  another thread.
-+ */
-+
-+DUK_INTERNAL duk_hthread *duk_hthread_alloc(duk_heap *heap, duk_uint_t hobject_flags) {
-+	duk_hthread *res;
-+
-+	res = (duk_hthread *) DUK_ALLOC(heap, sizeof(duk_hthread));
-+	if (!res) {
-+		return NULL;
-+	}
-+	DUK_MEMZERO(res, sizeof(duk_hthread));
-+
-+	duk__init_object_parts(heap, &res->obj, hobject_flags);
-+
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	res->heap = NULL;
-+	res->valstack = NULL;
-+	res->valstack_end = NULL;
-+	res->valstack_bottom = NULL;
-+	res->valstack_top = NULL;
-+	res->callstack = NULL;
-+	res->catchstack = NULL;
-+	res->resumer = NULL;
-+	res->compile_ctx = NULL,
-+#ifdef DUK_USE_HEAPPTR16
-+	res->strs16 = NULL;
-+#else
-+	res->strs = NULL;
-+#endif
-+	{
-+		int i;
-+		for (i = 0; i < DUK_NUM_BUILTINS; i++) {
-+			res->builtins[i] = NULL;
-+		}
-+	}
-+#endif
-+	/* when nothing is running, API calls are in non-strict mode */
-+	DUK_ASSERT(res->strict == 0);
-+
-+	res->heap = heap;
-+	res->valstack_max = DUK_VALSTACK_DEFAULT_MAX;
-+	res->callstack_max = DUK_CALLSTACK_DEFAULT_MAX;
-+	res->catchstack_max = DUK_CATCHSTACK_DEFAULT_MAX;
-+
-+	return res;
-+}
-+
-+#if 0  /* unused now */
-+DUK_INTERNAL duk_hobject *duk_hobject_alloc_checked(duk_hthread *thr, duk_uint_t hobject_flags) {
-+	duk_hobject *res = duk_hobject_alloc(thr->heap, hobject_flags);
-+	if (!res) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, "failed to allocate an object");
-+	}
-+	return res;
-+}
-+#endif
-+#line 1 "duk_hobject_enum.c"
-+/*
-+ *  Hobject enumeration support.
-+ *
-+ *  Creates an internal enumeration state object to be used e.g. with for-in
-+ *  enumeration.  The state object contains a snapshot of target object keys
-+ *  and internal control state for enumeration.  Enumerator flags allow caller
-+ *  to e.g. request internal/non-enumerable properties, and to enumerate only
-+ *  "own" properties.
-+ *
-+ *  Also creates the result value for e.g. Object.keys() based on the same
-+ *  internal structure.
-+ *
-+ *  This snapshot-based enumeration approach is used to simplify enumeration:
-+ *  non-snapshot-based approaches are difficult to reconcile with mutating
-+ *  the enumeration target, running multiple long-lived enumerators at the
-+ *  same time, garbage collection details, etc.  The downside is that the
-+ *  enumerator object is memory inefficient especially for iterating arrays.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* XXX: identify enumeration target with an object index (not top of stack) */
-+
-+/* must match exactly the number of internal properties inserted to enumerator */
-+#define DUK__ENUM_START_INDEX  2
-+
-+/*
-+ *  Helper to sort array index keys.  The keys are in the enumeration object
-+ *  entry part, starting from DUK__ENUM_START_INDEX, and the entry part is dense.
-+ *
-+ *  We use insertion sort because it is simple (leading to compact code,)
-+ *  works nicely in-place, and minimizes operations if data is already sorted
-+ *  or nearly sorted (which is a very common case here).  It also minimizes
-+ *  the use of element comparisons in general.  This is nice because element
-+ *  comparisons here involve re-parsing the string keys into numbers each
-+ *  time, which is naturally very expensive.
-+ *
-+ *  Note that the entry part values are all "true", e.g.
-+ *
-+ *    "1" -> true, "3" -> true, "2" -> true
-+ *
-+ *  so it suffices to only work in the key part without exchanging any keys,
-+ *  simplifying the sort.
-+ *
-+ *  http://en.wikipedia.org/wiki/Insertion_sort
-+ *
-+ *  (Compiles to about 160 bytes now as a stand-alone function.)
-+ */
-+
-+DUK_LOCAL void duk__sort_array_indices(duk_hthread *thr, duk_hobject *h_obj) {
-+	duk_hstring **keys;
-+	duk_hstring **p_curr, **p_insert, **p_end;
-+	duk_hstring *h_curr;
-+	duk_uarridx_t val_highest, val_curr, val_insert;
-+
-+	DUK_ASSERT(h_obj != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(h_obj) >= 2);  /* control props */
-+	DUK_UNREF(thr);
-+
-+	if (DUK_HOBJECT_GET_ENEXT(h_obj) <= 1 + DUK__ENUM_START_INDEX) {
-+		return;
-+	}
-+
-+	keys = DUK_HOBJECT_E_GET_KEY_BASE(thr->heap, h_obj);
-+	p_end = keys + DUK_HOBJECT_GET_ENEXT(h_obj);
-+	keys += DUK__ENUM_START_INDEX;
-+
-+	DUK_DDD(DUK_DDDPRINT("keys=%p, p_end=%p (after skipping enum props)",
-+	                     (void *) keys, (void *) p_end));
-+
-+#ifdef DUK_USE_DDDPRINT
-+	{
-+		duk_uint_fast32_t i;
-+		for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h_obj); i++) {
-+			DUK_DDD(DUK_DDDPRINT("initial: %ld %p -> %!O",
-+			                     (long) i,
-+			                     (void *) DUK_HOBJECT_E_GET_KEY_PTR(thr->heap, h_obj, i),
-+			                     (duk_heaphdr *) DUK_HOBJECT_E_GET_KEY(thr->heap, h_obj, i)));
-+		}
-+	}
-+#endif
-+
-+	val_highest = DUK_HSTRING_GET_ARRIDX_SLOW(keys[0]);
-+	for (p_curr = keys + 1; p_curr < p_end; p_curr++) {
-+		DUK_ASSERT(*p_curr != NULL);
-+		val_curr = DUK_HSTRING_GET_ARRIDX_SLOW(*p_curr);
-+
-+		if (val_curr >= val_highest) {
-+			DUK_DDD(DUK_DDDPRINT("p_curr=%p, p_end=%p, val_highest=%ld, val_curr=%ld -> "
-+			                     "already in correct order, next",
-+			                     (void *) p_curr, (void *) p_end, (long) val_highest, (long) val_curr));
-+			val_highest = val_curr;
-+			continue;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("p_curr=%p, p_end=%p, val_highest=%ld, val_curr=%ld -> "
-+		                     "needs to be inserted",
-+		                     (void *) p_curr, (void *) p_end, (long) val_highest, (long) val_curr));
-+
-+		/* Needs to be inserted; scan backwards, since we optimize
-+		 * for the case where elements are nearly in order.
-+		 */
-+
-+		p_insert = p_curr - 1;
-+		for (;;) {
-+			val_insert = DUK_HSTRING_GET_ARRIDX_SLOW(*p_insert);
-+			if (val_insert < val_curr) {
-+				DUK_DDD(DUK_DDDPRINT("p_insert=%p, val_insert=%ld, val_curr=%ld -> insert after this",
-+				                     (void *) p_insert, (long) val_insert, (long) val_curr));
-+				p_insert++;
-+				break;
-+			}
-+			if (p_insert == keys) {
-+				DUK_DDD(DUK_DDDPRINT("p_insert=%p -> out of keys, insert to beginning", (void *) p_insert));
-+				break;
-+			}
-+			DUK_DDD(DUK_DDDPRINT("p_insert=%p, val_insert=%ld, val_curr=%ld -> search backwards",
-+			                     (void *) p_insert, (long) val_insert, (long) val_curr));
-+			p_insert--;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("final p_insert=%p", (void *) p_insert));
-+
-+		/*        .-- p_insert   .-- p_curr
-+		 *        v              v
-+		 *  | ... | insert | ... | curr
-+		 */
-+
-+		h_curr = *p_curr;
-+		DUK_DDD(DUK_DDDPRINT("memmove: dest=%p, src=%p, size=%ld, h_curr=%p",
-+		                     (void *) (p_insert + 1), (void *) p_insert,
-+		                     (long) (p_curr - p_insert), (void *) h_curr));
-+
-+		DUK_MEMMOVE((void *) (p_insert + 1),
-+		            (void *) p_insert,
-+		            (size_t) ((p_curr - p_insert) * sizeof(duk_hstring *)));
-+		*p_insert = h_curr;
-+		/* keep val_highest */
-+	}
-+
-+#ifdef DUK_USE_DDDPRINT
-+	{
-+		duk_uint_fast32_t i;
-+		for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(h_obj); i++) {
-+			DUK_DDD(DUK_DDDPRINT("final: %ld %p -> %!O",
-+			                     (long) i,
-+			                     (void *) DUK_HOBJECT_E_GET_KEY_PTR(thr->heap, h_obj, i),
-+			                     (duk_heaphdr *) DUK_HOBJECT_E_GET_KEY(thr->heap, h_obj, i)));
-+		}
-+	}
-+#endif
-+}
-+
-+/*
-+ *  Create an internal enumerator object E, which has its keys ordered
-+ *  to match desired enumeration ordering.  Also initialize internal control
-+ *  properties for enumeration.
-+ *
-+ *  Note: if an array was used to hold enumeration keys instead, an array
-+ *  scan would be needed to eliminate duplicates found in the prototype chain.
-+ */
-+
-+DUK_INTERNAL void duk_hobject_enumerator_create(duk_context *ctx, duk_small_uint_t enum_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *enum_target;
-+	duk_hobject *curr;
-+	duk_hobject *res;
-+#if defined(DUK_USE_ES6_PROXY)
-+	duk_hobject *h_proxy_target;
-+	duk_hobject *h_proxy_handler;
-+	duk_hobject *h_trap_result;
-+#endif
-+	duk_uint_fast32_t i, len;  /* used for array, stack, and entry indices */
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	DUK_DDD(DUK_DDDPRINT("create enumerator, stack top: %ld", (long) duk_get_top(ctx)));
-+
-+	enum_target = duk_require_hobject(ctx, -1);
-+	DUK_ASSERT(enum_target != NULL);
-+
-+	duk_push_object_internal(ctx);
-+	res = duk_require_hobject(ctx, -1);
-+
-+	DUK_DDD(DUK_DDDPRINT("created internal object"));
-+
-+	/* [enum_target res] */
-+
-+	/* Target must be stored so that we can recheck whether or not
-+	 * keys still exist when we enumerate.  This is not done if the
-+	 * enumeration result comes from a proxy trap as there is no
-+	 * real object to check against.
-+	 */
-+	duk_push_hobject(ctx, enum_target);
-+	duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_TARGET);
-+
-+	/* Initialize index so that we skip internal control keys. */
-+	duk_push_int(ctx, DUK__ENUM_START_INDEX);
-+	duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_NEXT);
-+
-+	/*
-+	 *  Proxy object handling
-+	 */
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+	if (DUK_LIKELY((enum_flags & DUK_ENUM_NO_PROXY_BEHAVIOR) != 0)) {
-+		goto skip_proxy;
-+	}
-+	if (DUK_LIKELY(!duk_hobject_proxy_check(thr,
-+	                                        enum_target,
-+	                                        &h_proxy_target,
-+	                                        &h_proxy_handler))) {
-+		goto skip_proxy;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("proxy enumeration"));
-+	duk_push_hobject(ctx, h_proxy_handler);
-+	if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_ENUMERATE)) {
-+		/* No need to replace the 'enum_target' value in stack, only the
-+		 * enum_target reference.  This also ensures that the original
-+		 * enum target is reachable, which keeps the proxy and the proxy
-+		 * target reachable.  We do need to replace the internal _Target.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("no enumerate trap, enumerate proxy target instead"));
-+		DUK_DDD(DUK_DDDPRINT("h_proxy_target=%!O", (duk_heaphdr *) h_proxy_target));
-+		enum_target = h_proxy_target;
-+
-+		duk_push_hobject(ctx, enum_target);  /* -> [ ... enum_target res handler undefined target ] */
-+		duk_put_prop_stridx(ctx, -4, DUK_STRIDX_INT_TARGET);
-+
-+		duk_pop_2(ctx);  /* -> [ ... enum_target res ] */
-+		goto skip_proxy;
-+	}
-+
-+	/* [ ... enum_target res handler trap ] */
-+	duk_insert(ctx, -2);
-+	duk_push_hobject(ctx, h_proxy_target);    /* -> [ ... enum_target res trap handler target ] */
-+	duk_call_method(ctx, 1 /*nargs*/);        /* -> [ ... enum_target res trap_result ] */
-+	h_trap_result = duk_require_hobject(ctx, -1);
-+	DUK_UNREF(h_trap_result);
-+
-+	/* Copy trap result keys into the enumerator object. */
-+	len = (duk_uint_fast32_t) duk_get_length(ctx, -1);
-+	for (i = 0; i < len; i++) {
-+		/* XXX: not sure what the correct semantic details are here,
-+		 * e.g. handling of missing values (gaps), handling of non-array
-+		 * trap results, etc.
-+		 *
-+		 * For keys, we simply skip non-string keys which seems to be
-+		 * consistent with how e.g. Object.keys() will process proxy trap
-+		 * results (ES6 draft, Section 19.1.2.14).
-+		 */
-+		if (duk_get_prop_index(ctx, -1, i) && duk_is_string(ctx, -1)) {
-+			/* [ ... enum_target res trap_result val ] */
-+			duk_push_true(ctx);
-+			/* [ ... enum_target res trap_result val true ] */
-+			duk_put_prop(ctx, -4);
-+		} else {
-+			duk_pop(ctx);
-+		}
-+	}
-+	/* [ ... enum_target res trap_result ] */
-+	duk_pop(ctx);
-+	duk_remove(ctx, -2);
-+
-+	/* [ ... res ] */
-+
-+	/* The internal _Target property is kept pointing to the original
-+	 * enumeration target (the proxy object), so that the enumerator
-+	 * 'next' operation can read property values if so requested.  The
-+	 * fact that the _Target is a proxy disables key existence check
-+	 * during enumeration.
-+	 */
-+	DUK_DDD(DUK_DDDPRINT("proxy enumeration, final res: %!O", (duk_heaphdr *) res));
-+	goto compact_and_return;
-+
-+ skip_proxy:
-+#endif  /* DUK_USE_ES6_PROXY */
-+
-+	curr = enum_target;
-+	while (curr) {
-+		/*
-+		 *  Virtual properties.
-+		 *
-+		 *  String and buffer indices are virtual and always enumerable,
-+		 *  'length' is virtual and non-enumerable.  Array and arguments
-+		 *  object props have special behavior but are concrete.
-+		 */
-+
-+		if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr) ||
-+		    DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr)) {
-+			/* String and buffer enumeration behavior is identical now,
-+			 * so use shared handler.
-+			 */
-+			if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(curr)) {
-+				duk_hstring *h_val;
-+				h_val = duk_hobject_get_internal_value_string(thr->heap, curr);
-+				DUK_ASSERT(h_val != NULL);  /* string objects must not created without internal value */
-+				len = (duk_uint_fast32_t) DUK_HSTRING_GET_CHARLEN(h_val);
-+			} else {
-+				duk_hbuffer *h_val;
-+				DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr));
-+				h_val = duk_hobject_get_internal_value_buffer(thr->heap, curr);
-+				DUK_ASSERT(h_val != NULL);  /* buffer objects must not created without internal value */
-+				len = (duk_uint_fast32_t) DUK_HBUFFER_GET_SIZE(h_val);
-+			}
-+
-+			for (i = 0; i < len; i++) {
-+				duk_hstring *k;
-+
-+				k = duk_heap_string_intern_u32_checked(thr, i);
-+				DUK_ASSERT(k);
-+				duk_push_hstring(ctx, k);
-+				duk_push_true(ctx);
-+
-+				/* [enum_target res key true] */
-+				duk_put_prop(ctx, -3);
-+
-+				/* [enum_target res] */
-+			}
-+
-+			/* 'length' property is not enumerable, but is included if
-+			 * non-enumerable properties are requested.
-+			 */
-+
-+			if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
-+				duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
-+				duk_push_true(ctx);
-+				duk_put_prop(ctx, -3);
-+			}
-+		} else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(curr)) {
-+			if (enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE) {
-+				duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
-+				duk_push_true(ctx);
-+				duk_put_prop(ctx, -3);
-+			}
-+		}
-+
-+		/*
-+		 *  Array part
-+		 *
-+		 *  Note: ordering between array and entry part must match 'abandon array'
-+		 *  behavior in duk_hobject_props.c: key order after an array is abandoned
-+		 *  must be the same.
-+		 */
-+
-+		for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ASIZE(curr); i++) {
-+			duk_hstring *k;
-+			duk_tval *tv;
-+
-+			tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, curr, i);
-+			if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
-+				continue;
-+			}
-+			k = duk_heap_string_intern_u32_checked(thr, i);
-+			DUK_ASSERT(k);
-+
-+			duk_push_hstring(ctx, k);
-+			duk_push_true(ctx);
-+
-+			/* [enum_target res key true] */
-+			duk_put_prop(ctx, -3);
-+
-+			/* [enum_target res] */
-+		}
-+
-+		/*
-+		 *  Entries part
-+		 */
-+
-+		for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(curr); i++) {
-+			duk_hstring *k;
-+
-+			k = DUK_HOBJECT_E_GET_KEY(thr->heap, curr, i);
-+			if (!k) {
-+				continue;
-+			}
-+			if (!DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(thr->heap, curr, i) &&
-+			    !(enum_flags & DUK_ENUM_INCLUDE_NONENUMERABLE)) {
-+				continue;
-+			}
-+			if (DUK_HSTRING_HAS_INTERNAL(k) &&
-+			    !(enum_flags & DUK_ENUM_INCLUDE_INTERNAL)) {
-+				continue;
-+			}
-+			if ((enum_flags & DUK_ENUM_ARRAY_INDICES_ONLY) &&
-+			    (DUK_HSTRING_GET_ARRIDX_SLOW(k) == DUK_HSTRING_NO_ARRAY_INDEX)) {
-+				continue;
-+			}
-+
-+			DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, curr, i) ||
-+			           !DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE_PTR(thr->heap, curr, i)->v));
-+
-+			duk_push_hstring(ctx, k);
-+			duk_push_true(ctx);
-+
-+			/* [enum_target res key true] */
-+			duk_put_prop(ctx, -3);
-+
-+			/* [enum_target res] */
-+		}
-+
-+		if (enum_flags & DUK_ENUM_OWN_PROPERTIES_ONLY) {
-+			break;
-+		}
-+
-+		curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
-+	}
-+
-+	/* [enum_target res] */
-+
-+	duk_remove(ctx, -2);
-+
-+	/* [res] */
-+
-+	if ((enum_flags & (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) ==
-+	                  (DUK_ENUM_ARRAY_INDICES_ONLY | DUK_ENUM_SORT_ARRAY_INDICES)) {
-+		/*
-+		 *  Some E5/E5.1 algorithms require that array indices are iterated
-+		 *  in a strictly ascending order.  This is the case for e.g.
-+		 *  Array.prototype.forEach() and JSON.stringify() PropertyList
-+		 *  handling.
-+		 *
-+		 *  To ensure this property for arrays with an array part (and
-+		 *  arbitrary objects too, since e.g. forEach() can be applied
-+		 *  to an array), the caller can request that we sort the keys
-+		 *  here.
-+		 */
-+
-+		/* XXX: avoid this at least when enum_target is an Array, it has an
-+		 * array part, and no ancestor properties were included?  Not worth
-+		 * it for JSON, but maybe worth it for forEach().
-+		 */
-+
-+		/* XXX: may need a 'length' filter for forEach()
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("sort array indices by caller request"));
-+		duk__sort_array_indices(thr, res);
-+	}
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+ compact_and_return:
-+#endif
-+	/* compact; no need to seal because object is internal */
-+	duk_hobject_compact_props(thr, res);
-+
-+	DUK_DDD(DUK_DDDPRINT("created enumerator object: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
-+}
-+
-+/*
-+ *  Returns non-zero if a key and/or value was enumerated, and:
-+ *
-+ *   [enum] -> [key]        (get_value == 0)
-+ *   [enum] -> [key value]  (get_value == 1)
-+ *
-+ *  Returns zero without pushing anything on the stack otherwise.
-+ */
-+DUK_INTERNAL duk_bool_t duk_hobject_enumerator_next(duk_context *ctx, duk_bool_t get_value) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *e;
-+	duk_hobject *enum_target;
-+	duk_hstring *res = NULL;
-+	duk_uint_fast32_t idx;
-+	duk_bool_t check_existence;
-+
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* [... enum] */
-+
-+	e = duk_require_hobject(ctx, -1);
-+
-+	/* XXX use get tval ptr, more efficient */
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_NEXT);
-+	idx = (duk_uint_fast32_t) duk_require_uint(ctx, -1);
-+	duk_pop(ctx);
-+	DUK_DDD(DUK_DDDPRINT("enumeration: index is: %ld", (long) idx));
-+
-+	/* Enumeration keys are checked against the enumeration target (to see
-+	 * that they still exist).  In the proxy enumeration case _Target will
-+	 * be the proxy, and checking key existence against the proxy is not
-+	 * required (or sensible, as the keys may be fully virtual).
-+	 */
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET);
-+	enum_target = duk_require_hobject(ctx, -1);
-+	DUK_ASSERT(enum_target != NULL);
-+#if defined(DUK_USE_ES6_PROXY)
-+	check_existence = (!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(enum_target));
-+#else
-+	check_existence = 1;
-+#endif
-+	duk_pop(ctx);  /* still reachable */
-+
-+	DUK_DDD(DUK_DDDPRINT("getting next enum value, enum_target=%!iO, enumerator=%!iT",
-+	                     (duk_heaphdr *) enum_target, (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/* no array part */
-+	for (;;) {
-+		duk_hstring *k;
-+
-+		if (idx >= DUK_HOBJECT_GET_ENEXT(e)) {
-+			DUK_DDD(DUK_DDDPRINT("enumeration: ran out of elements"));
-+			break;
-+		}
-+
-+		/* we know these because enum objects are internally created */
-+		k = DUK_HOBJECT_E_GET_KEY(thr->heap, e, idx);
-+		DUK_ASSERT(k != NULL);
-+		DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, e, idx));
-+		DUK_ASSERT(!DUK_TVAL_IS_UNDEFINED_UNUSED(&DUK_HOBJECT_E_GET_VALUE(thr->heap, e, idx).v));
-+
-+		idx++;
-+
-+		/* recheck that the property still exists */
-+		if (check_existence && !duk_hobject_hasprop_raw(thr, enum_target, k)) {
-+			DUK_DDD(DUK_DDDPRINT("property deleted during enumeration, skip"));
-+			continue;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("enumeration: found element, key: %!O", (duk_heaphdr *) k));
-+		res = k;
-+		break;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("enumeration: updating next index to %ld", (long) idx));
-+
-+	duk_push_u32(ctx, (duk_uint32_t) idx);
-+	duk_put_prop_stridx(ctx, -2, DUK_STRIDX_INT_NEXT);
-+
-+	/* [... enum] */
-+
-+	if (res) {
-+		duk_push_hstring(ctx, res);
-+		if (get_value) {
-+			duk_push_hobject(ctx, enum_target);
-+			duk_dup(ctx, -2);      /* -> [... enum key enum_target key] */
-+			duk_get_prop(ctx, -2); /* -> [... enum key enum_target val] */
-+			duk_remove(ctx, -2);   /* -> [... enum key val] */
-+			duk_remove(ctx, -3);   /* -> [... key val] */
-+		} else {
-+			duk_remove(ctx, -2);   /* -> [... key] */
-+		}
-+		return 1;
-+	} else {
-+		duk_pop(ctx);  /* -> [...] */
-+		return 0;
-+	}
-+}
-+
-+/*
-+ *  Get enumerated keys in an Ecmascript array.  Matches Object.keys() behavior
-+ *  described in E5 Section 15.2.3.14.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_hobject_get_enumerated_keys(duk_context *ctx, duk_small_uint_t enum_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *e;
-+	duk_uint_fast32_t i;
-+	duk_uint_fast32_t idx;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(duk_get_hobject(ctx, -1) != NULL);
-+	DUK_UNREF(thr);
-+
-+	/* Create a temporary enumerator to get the (non-duplicated) key list;
-+	 * the enumerator state is initialized without being needed, but that
-+	 * has little impact.
-+	 */
-+
-+	duk_hobject_enumerator_create(ctx, enum_flags);
-+	duk_push_array(ctx);
-+
-+	/* [enum_target enum res] */
-+
-+	e = duk_require_hobject(ctx, -2);
-+	DUK_ASSERT(e != NULL);
-+
-+	idx = 0;
-+	for (i = DUK__ENUM_START_INDEX; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(e); i++) {
-+		duk_hstring *k;
-+
-+		k = DUK_HOBJECT_E_GET_KEY(thr->heap, e, i);
-+		DUK_ASSERT(k);  /* enumerator must have no keys deleted */
-+
-+		/* [enum_target enum res] */
-+		duk_push_hstring(ctx, k);
-+		duk_put_prop_index(ctx, -2, idx);
-+		idx++;
-+	}
-+
-+	/* [enum_target enum res] */
-+	duk_remove(ctx, -2);
-+
-+	/* [enum_target res] */
-+
-+	return 1;  /* return 1 to allow callers to tail call */
-+}
-+#line 1 "duk_hobject_finalizer.c"
-+/*
-+ *  Run an duk_hobject finalizer.  Used for both reference counting
-+ *  and mark-and-sweep algorithms.  Must never throw an error.
-+ *
-+ *  There is no return value.  Any return value or error thrown by
-+ *  the finalizer is ignored (although errors are debug logged).
-+ *
-+ *  Notes:
-+ *
-+ *    - The thread used for calling the finalizer is the same as the
-+ *      'thr' argument.  This may need to change later.
-+ *
-+ *    - The finalizer thread 'top' assertions are there because it is
-+ *      critical that strict stack policy is observed (i.e. no cruft
-+ *      left on the finalizer stack).
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_LOCAL duk_ret_t duk__finalize_helper(duk_context *ctx) {
-+	DUK_ASSERT(ctx != NULL);
-+
-+	DUK_DDD(DUK_DDDPRINT("protected finalization helper running"));
-+
-+	/* [... obj] */
-+
-+	/* XXX: Finalizer lookup should traverse the prototype chain (to allow
-+	 * inherited finalizers) but should not invoke accessors or proxy object
-+	 * behavior.  At the moment this lookup will invoke proxy behavior, so
-+	 * caller must ensure that this function is not called if the target is
-+	 * a Proxy.
-+	 */
-+
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_FINALIZER);  /* -> [... obj finalizer] */
-+	if (!duk_is_callable(ctx, -1)) {
-+		DUK_DDD(DUK_DDDPRINT("-> no finalizer or finalizer not callable"));
-+		return 0;
-+	}
-+	duk_dup(ctx, -2);  /* -> [... obj finalizer obj] */
-+	DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling finalizer"));
-+	duk_call(ctx, 1);  /* -> [... obj retval] */
-+	DUK_DDD(DUK_DDDPRINT("finalizer finished successfully"));
-+	return 0;
-+
-+	/* Note: we rely on duk_safe_call() to fix up the stack for the caller,
-+	 * so we don't need to pop stuff here.  There is no return value;
-+	 * caller determines rescued status based on object refcount.
-+	 */
-+}
-+
-+DUK_INTERNAL void duk_hobject_run_finalizer(duk_hthread *thr, duk_hobject *obj) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_ret_t rc;
-+#ifdef DUK_USE_ASSERTIONS
-+	duk_idx_t entry_top;
-+#endif
-+
-+	DUK_DDD(DUK_DDDPRINT("running object finalizer for object: %p", (void *) obj));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT_VALSTACK_SPACE(thr, 1);
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	entry_top = duk_get_top(ctx);
-+#endif
-+	/*
-+	 *  Get and call the finalizer.  All of this must be wrapped
-+	 *  in a protected call, because even getting the finalizer
-+	 *  may trigger an error (getter may throw one, for instance).
-+	 */
-+
-+	/* XXX: use a NULL error handler for the finalizer call? */
-+
-+	DUK_DDD(DUK_DDDPRINT("-> finalizer found, calling wrapped finalize helper"));
-+	duk_push_hobject(ctx, obj);  /* this also increases refcount by one */
-+	rc = duk_safe_call(ctx, duk__finalize_helper, 0 /*nargs*/, 1 /*nrets*/);  /* -> [... obj retval/error] */
-+	DUK_ASSERT_TOP(ctx, entry_top + 2);  /* duk_safe_call discipline */
-+
-+	if (rc != DUK_EXEC_SUCCESS) {
-+		/* Note: we ask for one return value from duk_safe_call to get this
-+		 * error debugging here.
-+		 */
-+		DUK_D(DUK_DPRINT("wrapped finalizer call failed for object %p (ignored); error: %!T",
-+		                 (void *) obj, (duk_tval *) duk_get_tval(ctx, -1)));
-+	}
-+	duk_pop_2(ctx);  /* -> [...] */
-+
-+	DUK_ASSERT_TOP(ctx, entry_top);
-+}
-+#line 1 "duk_hobject_misc.c"
-+/*
-+ *  Misc support functions
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_prototype_chain_contains(duk_hthread *thr, duk_hobject *h, duk_hobject *p, duk_bool_t ignore_loop) {
-+	duk_uint_t sanity;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(h != NULL);
-+	/* allow 'p' to be NULL; then the result is always false */
-+
-+	sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
-+	do {
-+		if (h == p) {
-+			return 1;
-+		}
-+
-+		if (sanity-- == 0) {
-+			if (ignore_loop) {
-+				break;
-+			} else {
-+				DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
-+			}
-+		}
-+		h = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
-+	} while (h);
-+
-+	return 0;
-+}
-+
-+DUK_INTERNAL void duk_hobject_set_prototype(duk_hthread *thr, duk_hobject *h, duk_hobject *p) {
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+	duk_hobject *tmp;
-+
-+	DUK_ASSERT(h);
-+	tmp = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, h);
-+	DUK_HOBJECT_SET_PROTOTYPE(thr->heap, h, p);
-+	DUK_HOBJECT_INCREF_ALLOWNULL(thr, p);  /* avoid problems if p == h->prototype */
-+	DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+#else
-+	DUK_ASSERT(h);
-+	DUK_UNREF(thr);
-+	DUK_HOBJECT_SET_PROTOTYPE(thr->heap, h, p);
-+#endif
-+}
-+#line 1 "duk_hobject_pc2line.c"
-+/*
-+ *  Helpers for creating and querying pc2line debug data, which
-+ *  converts a bytecode program counter to a source line number.
-+ *
-+ *  The run-time pc2line data is bit-packed, and documented in:
-+ *
-+ *    doc/function-objects.txt
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#if defined(DUK_USE_PC2LINE)
-+
-+/* Generate pc2line data for an instruction sequence, leaving a buffer on stack top. */
-+DUK_INTERNAL void duk_hobject_pc2line_pack(duk_hthread *thr, duk_compiler_instr *instrs, duk_uint_fast32_t length) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hbuffer_dynamic *h_buf;
-+	duk_bitencoder_ctx be_ctx_alloc;
-+	duk_bitencoder_ctx *be_ctx = &be_ctx_alloc;
-+	duk_uint32_t *hdr;
-+	duk_size_t new_size;
-+	duk_uint_fast32_t num_header_entries;
-+	duk_uint_fast32_t curr_offset;
-+	duk_int_fast32_t curr_line, next_line, diff_line;
-+	duk_uint_fast32_t curr_pc;
-+	duk_uint_fast32_t hdr_index;
-+
-+	DUK_ASSERT(length <= DUK_COMPILER_MAX_BYTECODE_LENGTH);
-+
-+	/* XXX: add proper spare handling to dynamic buffer, to minimize
-+	 * reallocs; currently there is no spare at all.
-+	 */
-+
-+	num_header_entries = (length + DUK_PC2LINE_SKIP - 1) / DUK_PC2LINE_SKIP;
-+	curr_offset = (duk_uint_fast32_t) (sizeof(duk_uint32_t) + num_header_entries * sizeof(duk_uint32_t) * 2);
-+
-+	duk_push_dynamic_buffer(ctx, (duk_size_t) curr_offset);
-+	h_buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(h_buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buf));
-+
-+	hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
-+	DUK_ASSERT(hdr != NULL);
-+	hdr[0] = (duk_uint32_t) length;  /* valid pc range is [0, length[ */
-+
-+	curr_pc = 0U;
-+	while (curr_pc < length) {
-+		new_size = (duk_size_t) (curr_offset + DUK_PC2LINE_MAX_DIFF_LENGTH);
-+		duk_hbuffer_resize(thr, h_buf, new_size, new_size);
-+
-+		hdr = (duk_uint32_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, h_buf);
-+		DUK_ASSERT(hdr != NULL);
-+		DUK_ASSERT(curr_pc < length);
-+		hdr_index = 1 + (curr_pc / DUK_PC2LINE_SKIP) * 2;
-+		curr_line = (duk_int_fast32_t) instrs[curr_pc].line;
-+		hdr[hdr_index + 0] = (duk_uint32_t) curr_line;
-+		hdr[hdr_index + 1] = (duk_uint32_t) curr_offset;
-+
-+#if 0
-+		DUK_DDD(DUK_DDDPRINT("hdr[%ld]: pc=%ld line=%ld offset=%ld",
-+		                     (long) (curr_pc / DUK_PC2LINE_SKIP),
-+		                     (long) curr_pc,
-+		                     (long) hdr[hdr_index + 0],
-+		                     (long) hdr[hdr_index + 1]));
-+#endif
-+
-+		DUK_MEMZERO(be_ctx, sizeof(*be_ctx));
-+		be_ctx->data = ((duk_uint8_t *) hdr) + curr_offset;
-+		be_ctx->length = (duk_size_t) DUK_PC2LINE_MAX_DIFF_LENGTH;
-+
-+		for (;;) {
-+			curr_pc++;
-+			if ( ((curr_pc % DUK_PC2LINE_SKIP) == 0) ||  /* end of diff run */
-+			     (curr_pc >= length) ) {                 /* end of bytecode */
-+				break;
-+			}
-+			DUK_ASSERT(curr_pc < length);
-+			next_line = (duk_int32_t) instrs[curr_pc].line;
-+			diff_line = next_line - curr_line;
-+
-+#if 0
-+			DUK_DDD(DUK_DDDPRINT("curr_line=%ld, next_line=%ld -> diff_line=%ld",
-+			                     (long) curr_line, (long) next_line, (long) diff_line));
-+#endif
-+
-+			if (diff_line == 0) {
-+				/* 0 */
-+				duk_be_encode(be_ctx, 0, 1);
-+			} else if (diff_line >= 1 && diff_line <= 4) {
-+				/* 1 0 <2 bits> */
-+				duk_be_encode(be_ctx, (0x02 << 2) + (diff_line - 1), 4);
-+			} else if (diff_line >= -0x80 && diff_line <= 0x7f) {
-+				/* 1 1 0 <8 bits> */
-+				DUK_ASSERT(diff_line + 0x80 >= 0 && diff_line + 0x80 <= 0xff);
-+				duk_be_encode(be_ctx, (0x06 << 8) + (diff_line + 0x80), 11);
-+			} else {
-+				/* 1 1 1 <32 bits>
-+				 * Encode in two parts to avoid bitencode 24-bit limitation
-+				 */
-+				duk_be_encode(be_ctx, (0x07 << 16) + ((next_line >> 16) & 0xffffU), 19);
-+				duk_be_encode(be_ctx, next_line & 0xffffU, 16);
-+			}
-+
-+			curr_line = next_line;
-+		}
-+
-+		duk_be_finish(be_ctx);
-+		DUK_ASSERT(!be_ctx->truncated);
-+
-+		/* be_ctx->offset == length of encoded bitstream */
-+		curr_offset += (duk_uint_fast32_t) be_ctx->offset;
-+	}
-+
-+	/* compact */
-+	new_size = (duk_size_t) curr_offset;
-+	duk_hbuffer_resize(thr, h_buf, new_size, new_size);
-+
-+	(void) duk_to_fixed_buffer(ctx, -1, NULL);
-+
-+	DUK_DDD(DUK_DDDPRINT("final pc2line data: pc_limit=%ld, length=%ld, %lf bits/opcode --> %!ixT",
-+	                     (long) length, (long) new_size, (double) new_size * 8.0 / (double) length,
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+}
-+
-+/* PC is unsigned.  If caller does PC arithmetic and gets a negative result,
-+ * it will map to a large PC which is out of bounds and causes a zero to be
-+ * returned.
-+ */
-+DUK_LOCAL duk_uint_fast32_t duk__hobject_pc2line_query_raw(duk_hthread *thr, duk_hbuffer_fixed *buf, duk_uint_fast32_t pc) {
-+	duk_bitdecoder_ctx bd_ctx_alloc;
-+	duk_bitdecoder_ctx *bd_ctx = &bd_ctx_alloc;
-+	duk_uint32_t *hdr;
-+	duk_uint_fast32_t start_offset;
-+	duk_uint_fast32_t pc_limit;
-+	duk_uint_fast32_t hdr_index;
-+	duk_uint_fast32_t pc_base;
-+	duk_uint_fast32_t n;
-+	duk_uint_fast32_t curr_line;
-+
-+	DUK_ASSERT(buf != NULL);
-+	DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) buf));
-+	DUK_UNREF(thr);
-+
-+	/*
-+	 *  Use the index in the header to find the right starting point
-+	 */
-+
-+	hdr_index = pc / DUK_PC2LINE_SKIP;
-+	pc_base = hdr_index * DUK_PC2LINE_SKIP;
-+	n = pc - pc_base;
-+
-+	if (DUK_HBUFFER_FIXED_GET_SIZE(buf) <= sizeof(duk_uint32_t)) {
-+		DUK_DD(DUK_DDPRINT("pc2line lookup failed: buffer is smaller than minimal header"));
-+		goto error;
-+	}
-+
-+	hdr = (duk_uint32_t *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, buf);
-+	pc_limit = hdr[0];
-+	if (pc >= pc_limit) {
-+		/* Note: pc is unsigned and cannot be negative */
-+		DUK_DD(DUK_DDPRINT("pc2line lookup failed: pc out of bounds (pc=%ld, limit=%ld)",
-+		                   (long) pc, (long) pc_limit));
-+		goto error;
-+	}
-+
-+	curr_line = hdr[1 + hdr_index * 2];
-+	start_offset = hdr[1 + hdr_index * 2 + 1];
-+	if ((duk_size_t) start_offset > DUK_HBUFFER_FIXED_GET_SIZE(buf)) {
-+		DUK_DD(DUK_DDPRINT("pc2line lookup failed: start_offset out of bounds (start_offset=%ld, buffer_size=%ld)",
-+		                   (long) start_offset, (long) DUK_HBUFFER_GET_SIZE((duk_hbuffer *) buf)));
-+		goto error;
-+	}
-+
-+	/*
-+	 *  Iterate the bitstream (line diffs) until PC is reached
-+	 */
-+
-+	DUK_MEMZERO(bd_ctx, sizeof(*bd_ctx));
-+	bd_ctx->data = ((duk_uint8_t *) hdr) + start_offset;
-+	bd_ctx->length = (duk_size_t) (DUK_HBUFFER_FIXED_GET_SIZE(buf) - start_offset);
-+
-+#if 0
-+	DUK_DDD(DUK_DDDPRINT("pc2line lookup: pc=%ld -> hdr_index=%ld, pc_base=%ld, n=%ld, start_offset=%ld",
-+	                     (long) pc, (long) hdr_index, (long) pc_base, (long) n, (long) start_offset));
-+#endif
-+
-+	while (n > 0) {
-+#if 0
-+		DUK_DDD(DUK_DDDPRINT("lookup: n=%ld, curr_line=%ld", (long) n, (long) curr_line));
-+#endif
-+
-+		if (duk_bd_decode_flag(bd_ctx)) {
-+			if (duk_bd_decode_flag(bd_ctx)) {
-+				if (duk_bd_decode_flag(bd_ctx)) {
-+					/* 1 1 1 <32 bits> */
-+					duk_uint_fast32_t t;
-+					t = duk_bd_decode(bd_ctx, 16);  /* workaround: max nbits = 24 now */
-+					t = (t << 16) + duk_bd_decode(bd_ctx, 16);
-+					curr_line = t;
-+				} else {
-+					/* 1 1 0 <8 bits> */
-+					duk_uint_fast32_t t;
-+					t = duk_bd_decode(bd_ctx, 8);
-+					curr_line = curr_line + t - 0x80;
-+				}
-+			} else {
-+				/* 1 0 <2 bits> */
-+				duk_uint_fast32_t t;
-+				t = duk_bd_decode(bd_ctx, 2);
-+				curr_line = curr_line + t + 1;
-+			}
-+		} else {
-+			/* 0: no change */
-+		}
-+
-+		n--;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("pc2line lookup result: pc %ld -> line %ld", (long) pc, (long) curr_line));
-+	return curr_line;
-+
-+ error:
-+	DUK_D(DUK_DPRINT("pc2line conversion failed for pc=%ld", (long) pc));
-+	return 0;
-+}
-+
-+DUK_INTERNAL duk_uint_fast32_t duk_hobject_pc2line_query(duk_context *ctx, duk_idx_t idx_func, duk_uint_fast32_t pc) {
-+	duk_hbuffer_fixed *pc2line;
-+	duk_uint_fast32_t line;
-+
-+	/* XXX: now that pc2line is used by the debugger quite heavily in
-+	 * checked execution, this should be optimized to avoid value stack
-+	 * and perhaps also implement some form of pc2line caching (see
-+	 * future work in debugger.rst).
-+	 */
-+
-+	duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_PC2LINE);
-+	pc2line = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1);
-+	if (pc2line != NULL) {
-+		DUK_ASSERT(!DUK_HBUFFER_HAS_DYNAMIC((duk_hbuffer *) pc2line));
-+		line = duk__hobject_pc2line_query_raw((duk_hthread *) ctx, pc2line, (duk_uint_fast32_t) pc);
-+	} else {
-+		line = 0;
-+	}
-+	duk_pop(ctx);
-+
-+	return line;
-+}
-+
-+#endif  /* DUK_USE_PC2LINE */
-+#line 1 "duk_hobject_props.c"
-+/*
-+ *  Hobject property set/get functionality.
-+ *
-+ *  This is very central functionality for size, performance, and compliance.
-+ *  It is also rather intricate; see hobject-algorithms.txt for discussion on
-+ *  the algorithms and memory-management.txt for discussion on refcounts and
-+ *  side effect issues.
-+ *
-+ *  Notes:
-+ *
-+ *    - It might be tempting to assert "refcount nonzero" for objects
-+ *      being operated on, but that's not always correct: objects with
-+ *      a zero refcount may be operated on by the refcount implementation
-+ *      (finalization) for instance.  Hence, no refcount assertions are made.
-+ *
-+ *    - Many operations (memory allocation, identifier operations, etc)
-+ *      may cause arbitrary side effects (e.g. through GC and finalization).
-+ *      These side effects may invalidate duk_tval pointers which point to
-+ *      areas subject to reallocation (like value stack).  Heap objects
-+ *      themselves have stable pointers.  Holding heap object pointers or
-+ *      duk_tval copies is not problematic with respect to side effects;
-+ *      care must be taken when holding and using argument duk_tval pointers.
-+ *
-+ *    - If a finalizer is executed, it may operate on the the same object
-+ *      we're currently dealing with.  For instance, the finalizer might
-+ *      delete a certain property which has already been looked up and
-+ *      confirmed to exist.  Ideally finalizers would be disabled if GC
-+ *      happens during property access.  At the moment property table realloc
-+ *      disables finalizers, and all DECREFs may cause arbitrary changes so
-+ *      handle DECREF carefully.
-+ *
-+ *    - The order of operations for a DECREF matters.  When DECREF is executed,
-+ *      the entire object graph must be consistent; note that a refzero may
-+ *      lead to a mark-and-sweep through a refcount finalizer.
-+ */
-+
-+/*
-+ *  XXX: array indices are mostly typed as duk_uint32_t here; duk_uarridx_t
-+ *  might be more appropriate.
-+ */
-+
-+/*
-+ *  XXX: duk_uint_fast32_t should probably be used in many places here.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Local defines
-+ */
-+
-+#define DUK__NO_ARRAY_INDEX             DUK_HSTRING_NO_ARRAY_INDEX
-+
-+/* hash probe sequence */
-+#define DUK__HASH_INITIAL(hash,h_size)  DUK_HOBJECT_HASH_INITIAL((hash),(h_size))
-+#define DUK__HASH_PROBE_STEP(hash)      DUK_HOBJECT_HASH_PROBE_STEP((hash))
-+
-+/* marker values for hash part */
-+#define DUK__HASH_UNUSED                DUK_HOBJECT_HASHIDX_UNUSED
-+#define DUK__HASH_DELETED               DUK_HOBJECT_HASHIDX_DELETED
-+
-+/* valstack space that suffices for all local calls, including recursion
-+ * of other than Duktape calls (getters etc)
-+ */
-+#define DUK__VALSTACK_SPACE             10
-+
-+/* valstack space allocated especially for proxy lookup which does a
-+ * recursive property lookup
-+ */
-+#define DUK__VALSTACK_PROXY_LOOKUP      20
-+
-+/*
-+ *  Local prototypes
-+ */
-+
-+#define DUK__DESC_FLAG_PUSH_VALUE          (1 << 0)  /* push value to stack */
-+#define DUK__DESC_FLAG_IGNORE_PROTOLOOP    (1 << 1)  /* don't throw for prototype loop */
-+
-+DUK_LOCAL_DECL duk_bool_t duk__check_arguments_map_for_get(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc);
-+DUK_LOCAL_DECL void duk__check_arguments_map_for_put(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc, duk_bool_t throw_flag);
-+DUK_LOCAL_DECL void duk__check_arguments_map_for_delete(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc);
-+
-+DUK_LOCAL_DECL duk_bool_t duk__handle_put_array_length_smaller(duk_hthread *thr, duk_hobject *obj, duk_uint32_t old_len, duk_uint32_t new_len, duk_bool_t force_flag, duk_uint32_t *out_result_len);
-+DUK_LOCAL_DECL duk_bool_t duk__handle_put_array_length(duk_hthread *thr, duk_hobject *obj);
-+
-+DUK_LOCAL_DECL duk_bool_t duk__get_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags);
-+DUK_LOCAL_DECL duk_bool_t duk__get_own_property_desc_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_uint32_t arr_idx, duk_propdesc *out_desc, duk_small_uint_t flags);
-+DUK_LOCAL_DECL duk_bool_t duk__get_own_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags);
-+
-+/*
-+ *  Misc helpers
-+ */
-+
-+/* Convert a duk_tval number (caller checks) to a 32-bit index.  Returns
-+ * DUK__NO_ARRAY_INDEX if the number is not whole or not a valid array
-+ * index.
-+ */
-+/* XXX: for fastints, could use a variant which assumes a double duk_tval
-+ * (and doesn't need to check for fastint again).
-+ */
-+DUK_LOCAL duk_uint32_t duk__tval_number_to_arr_idx(duk_tval *tv) {
-+	duk_double_t dbl;
-+	duk_uint32_t idx;
-+
-+	DUK_ASSERT(tv != NULL);
-+	DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+
-+	dbl = DUK_TVAL_GET_NUMBER(tv);
-+	idx = (duk_uint32_t) dbl;
-+	if ((duk_double_t) idx == dbl) {
-+	        /* Is whole and within 32 bit range.  If the value happens to be 0xFFFFFFFF,
-+		 * it's not a valid array index but will then match DUK__NO_ARRAY_INDEX.
-+		 */
-+		return idx;
-+	}
-+	return DUK__NO_ARRAY_INDEX;
-+}
-+
-+#if defined(DUK_USE_FASTINT)
-+/* Convert a duk_tval fastint (caller checks) to a 32-bit index. */
-+DUK_LOCAL duk_uint32_t duk__tval_fastint_to_arr_idx(duk_tval *tv) {
-+	duk_int64_t t;
-+
-+	DUK_ASSERT(tv != NULL);
-+	DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv));
-+
-+	t = DUK_TVAL_GET_FASTINT(tv);
-+	if ((t & ~0xffffffffULL) != 0) {
-+		/* Catches >0x100000000 and negative values. */
-+		return DUK__NO_ARRAY_INDEX;
-+	}
-+
-+	/* If the value happens to be 0xFFFFFFFF, it's not a valid array index
-+	 * but will then match DUK__NO_ARRAY_INDEX.
-+	 */
-+	return (duk_uint32_t) t;
-+}
-+#endif  /* DUK_USE_FASTINT */
-+
-+/* Push an arbitrary duk_tval to the stack, coerce it to string, and return
-+ * both a duk_hstring pointer and an array index (or DUK__NO_ARRAY_INDEX).
-+ */
-+DUK_LOCAL duk_uint32_t duk__push_tval_to_hstring_arr_idx(duk_context *ctx, duk_tval *tv, duk_hstring **out_h) {
-+	duk_uint32_t arr_idx;
-+	duk_hstring *h;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(tv != NULL);
-+	DUK_ASSERT(out_h != NULL);
-+
-+	duk_push_tval(ctx, tv);
-+	duk_to_string(ctx, -1);
-+	h = duk_get_hstring(ctx, -1);
-+	DUK_ASSERT(h != NULL);
-+	*out_h = h;
-+
-+	arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(h);
-+	return arr_idx;
-+}
-+
-+/* String is an own (virtual) property of a lightfunc. */
-+DUK_LOCAL duk_bool_t duk__key_is_lightfunc_ownprop(duk_hthread *thr, duk_hstring *key) {
-+	return (key == DUK_HTHREAD_STRING_LENGTH(thr) ||
-+	        key == DUK_HTHREAD_STRING_NAME(thr));
-+}
-+
-+/*
-+ *  Helpers for managing property storage size
-+ */
-+
-+/* Get default hash part size for a certain entry part size. */
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+DUK_LOCAL duk_uint32_t duk__get_default_h_size(duk_uint32_t e_size) {
-+	DUK_ASSERT(e_size <= DUK_HOBJECT_MAX_PROPERTIES);
-+
-+	if (e_size >= DUK_HOBJECT_E_USE_HASH_LIMIT) {
-+		duk_uint32_t res;
-+
-+		/* result: hash_prime(floor(1.2 * e_size)) */
-+		res = duk_util_get_hash_prime(e_size + e_size / DUK_HOBJECT_H_SIZE_DIVISOR);
-+
-+		/* if fails, e_size will be zero = not an issue, except performance-wise */
-+		DUK_ASSERT(res == 0 || res > e_size);
-+		return res;
-+	} else {
-+		return 0;
-+	}
-+}
-+#endif  /* USE_PROP_HASH_PART */
-+
-+/* Get minimum entry part growth for a certain size. */
-+DUK_LOCAL duk_uint32_t duk__get_min_grow_e(duk_uint32_t e_size) {
-+	duk_uint32_t res;
-+
-+	DUK_ASSERT(e_size <= DUK_HOBJECT_MAX_PROPERTIES);
-+
-+	res = (e_size + DUK_HOBJECT_E_MIN_GROW_ADD) / DUK_HOBJECT_E_MIN_GROW_DIVISOR;
-+	DUK_ASSERT(res >= 1);  /* important for callers */
-+	return res;
-+}
-+
-+/* Get minimum array part growth for a certain size. */
-+DUK_LOCAL duk_uint32_t duk__get_min_grow_a(duk_uint32_t a_size) {
-+	duk_uint32_t res;
-+
-+	DUK_ASSERT((duk_size_t) a_size <= DUK_HOBJECT_MAX_PROPERTIES);
-+
-+	res = (a_size + DUK_HOBJECT_A_MIN_GROW_ADD) / DUK_HOBJECT_A_MIN_GROW_DIVISOR;
-+	DUK_ASSERT(res >= 1);  /* important for callers */
-+	return res;
-+}
-+
-+/* Count actually used entry part entries (non-NULL keys). */
-+DUK_LOCAL duk_uint32_t duk__count_used_e_keys(duk_hthread *thr, duk_hobject *obj) {
-+	duk_uint_fast32_t i;
-+	duk_uint_fast32_t n = 0;
-+	duk_hstring **e;
-+
-+	DUK_ASSERT(obj != NULL);
-+	DUK_UNREF(thr);
-+
-+	e = DUK_HOBJECT_E_GET_KEY_BASE(thr->heap, obj);
-+	for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
-+		if (*e++) {
-+			n++;
-+		}
-+	}
-+	return (duk_uint32_t) n;
-+}
-+
-+/* Count actually used array part entries and array minimum size.
-+ * NOTE: 'out_min_size' can be computed much faster by starting from the
-+ * end and breaking out early when finding first used entry, but this is
-+ * not needed now.
-+ */
-+DUK_LOCAL void duk__compute_a_stats(duk_hthread *thr, duk_hobject *obj, duk_uint32_t *out_used, duk_uint32_t *out_min_size) {
-+	duk_uint_fast32_t i;
-+	duk_uint_fast32_t used = 0;
-+	duk_uint_fast32_t highest_idx = (duk_uint_fast32_t) -1;  /* see below */
-+	duk_tval *a;
-+
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(out_used != NULL);
-+	DUK_ASSERT(out_min_size != NULL);
-+	DUK_UNREF(thr);
-+
-+	a = DUK_HOBJECT_A_GET_BASE(thr->heap, obj);
-+	for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) {
-+		duk_tval *tv = a++;
-+		if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
-+			used++;
-+			highest_idx = i;
-+		}
-+	}
-+
-+	/* Initial value for highest_idx is -1 coerced to unsigned.  This
-+	 * is a bit odd, but (highest_idx + 1) will then wrap to 0 below
-+	 * for out_min_size as intended.
-+	 */
-+
-+	*out_used = used;
-+	*out_min_size = highest_idx + 1;  /* 0 if no used entries */
-+}
-+
-+/* Check array density and indicate whether or not the array part should be abandoned. */
-+DUK_LOCAL duk_bool_t duk__abandon_array_density_check(duk_uint32_t a_used, duk_uint32_t a_size) {
-+	/*
-+	 *  Array abandon check; abandon if:
-+	 *
-+	 *    new_used / new_size < limit
-+	 *    new_used < limit * new_size        || limit is 3 bits fixed point
-+	 *    new_used < limit' / 8 * new_size   || *8
-+	 *    8*new_used < limit' * new_size     || :8
-+	 *    new_used < limit' * (new_size / 8)
-+	 *
-+	 *  Here, new_used = a_used, new_size = a_size.
-+	 *
-+	 *  Note: some callers use approximate values for a_used and/or a_size
-+	 *  (e.g. dropping a '+1' term).  This doesn't affect the usefulness
-+	 *  of the check, but may confuse debugging.
-+	 */
-+
-+	return (a_used < DUK_HOBJECT_A_ABANDON_LIMIT * (a_size >> 3));
-+}
-+
-+/* Fast check for extending array: check whether or not a slow density check is required. */
-+DUK_LOCAL duk_bool_t duk__abandon_array_slow_check_required(duk_uint32_t arr_idx, duk_uint32_t old_size) {
-+	/*
-+	 *  In a fast check we assume old_size equals old_used (i.e., existing
-+	 *  array is fully dense).
-+	 *
-+	 *  Slow check if:
-+	 *
-+	 *    (new_size - old_size) / old_size > limit
-+	 *    new_size - old_size > limit * old_size
-+	 *    new_size > (1 + limit) * old_size        || limit' is 3 bits fixed point
-+	 *    new_size > (1 + (limit' / 8)) * old_size || * 8
-+	 *    8 * new_size > (8 + limit') * old_size   || : 8
-+	 *    new_size > (8 + limit') * (old_size / 8)
-+	 *    new_size > limit'' * (old_size / 8)      || limit'' = 9 -> max 25% increase
-+	 *    arr_idx + 1 > limit'' * (old_size / 8)
-+	 *
-+	 *  This check doesn't work well for small values, so old_size is rounded
-+	 *  up for the check (and the '+ 1' of arr_idx can be ignored in practice):
-+	 *
-+	 *    arr_idx > limit'' * ((old_size + 7) / 8)
-+	 */
-+
-+	return (arr_idx > DUK_HOBJECT_A_FAST_RESIZE_LIMIT * ((old_size + 7) >> 3));
-+}
-+
-+/*
-+ *  Proxy helpers
-+ */
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+DUK_INTERNAL duk_bool_t duk_hobject_proxy_check(duk_hthread *thr, duk_hobject *obj, duk_hobject **out_target, duk_hobject **out_handler) {
-+	duk_tval *tv_target;
-+	duk_tval *tv_handler;
-+	duk_hobject *h_target;
-+	duk_hobject *h_handler;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(out_target != NULL);
-+	DUK_ASSERT(out_handler != NULL);
-+
-+	/* Caller doesn't need to check exotic proxy behavior (but does so for
-+	 * some fast paths).
-+	 */
-+	if (DUK_LIKELY(!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) {
-+		return 0;
-+	}
-+
-+	tv_handler = duk_hobject_find_existing_entry_tval_ptr(thr->heap, obj, DUK_HTHREAD_STRING_INT_HANDLER(thr));
-+	if (!tv_handler) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REVOKED);
-+		return 0;
-+	}
-+	DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_handler));
-+	h_handler = DUK_TVAL_GET_OBJECT(tv_handler);
-+	DUK_ASSERT(h_handler != NULL);
-+	*out_handler = h_handler;
-+	tv_handler = NULL;  /* avoid issues with relocation */
-+
-+	tv_target = duk_hobject_find_existing_entry_tval_ptr(thr->heap, obj, DUK_HTHREAD_STRING_INT_TARGET(thr));
-+	if (!tv_target) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REVOKED);
-+		return 0;
-+	}
-+	DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_target));
-+	h_target = DUK_TVAL_GET_OBJECT(tv_target);
-+	DUK_ASSERT(h_target != NULL);
-+	*out_target = h_target;
-+	tv_target = NULL;  /* avoid issues with relocation */
-+
-+	return 1;
-+}
-+#endif
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+DUK_LOCAL duk_bool_t duk__proxy_check_prop(duk_hthread *thr, duk_hobject *obj, duk_small_uint_t stridx_trap, duk_tval *tv_key, duk_hobject **out_target) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *h_handler;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(tv_key != NULL);
-+	DUK_ASSERT(out_target != NULL);
-+
-+	if (!duk_hobject_proxy_check(thr, obj, out_target, &h_handler)) {
-+		return 0;
-+	}
-+	DUK_ASSERT(*out_target != NULL);
-+	DUK_ASSERT(h_handler != NULL);
-+
-+	/* XXX: At the moment Duktape accesses internal keys like _Finalizer using a
-+	 * normal property set/get which would allow a proxy handler to interfere with
-+	 * such behavior and to get access to internal key strings.  This is not a problem
-+	 * as such because internal key strings can be created in other ways too (e.g.
-+	 * through buffers).  The best fix is to change Duktape internal lookups to
-+	 * skip proxy behavior.  Until that, internal property accesses bypass the
-+	 * proxy and are applied to the target (as if the handler did not exist).
-+	 * This has some side effects, see test-bi-proxy-internal-keys.js.
-+	 */
-+
-+	if (DUK_TVAL_IS_STRING(tv_key)) {
-+		duk_hstring *h_key = (duk_hstring *) DUK_TVAL_GET_STRING(tv_key);
-+		DUK_ASSERT(h_key != NULL);
-+		if (DUK_HSTRING_HAS_INTERNAL(h_key)) {
-+			DUK_DDD(DUK_DDDPRINT("internal key, skip proxy handler and apply to target"));
-+			return 0;
-+		}
-+	}
-+
-+	/* The handler is looked up with a normal property lookup; it may be an
-+	 * accessor or the handler object itself may be a proxy object.  If the
-+	 * handler is a proxy, we need to extend the valstack as we make a
-+	 * recursive proxy check without a function call in between (in fact
-+	 * there is no limit to the potential recursion here).
-+	 *
-+	 * (For sanity, proxy creation rejects another proxy object as either
-+	 * the handler or the target at the moment so recursive proxy cases
-+	 * are not realized now.)
-+	 */
-+
-+	/* XXX: C recursion limit if proxies are allowed as handler/target values */
-+
-+	duk_require_stack(ctx, DUK__VALSTACK_PROXY_LOOKUP);
-+	duk_push_hobject(ctx, h_handler);
-+	if (duk_get_prop_stridx(ctx, -1, stridx_trap)) {
-+		/* -> [ ... handler trap ] */
-+		duk_insert(ctx, -2);  /* -> [ ... trap handler ] */
-+
-+		/* stack prepped for func call: [ ... trap handler ] */
-+		return 1;
-+	} else {
-+		duk_pop_2(ctx);
-+		return 0;
-+	}
-+}
-+#endif  /* DUK_USE_ES6_PROXY */
-+
-+/*
-+ *  Reallocate property allocation, moving properties to the new allocation.
-+ *
-+ *  Includes key compaction, rehashing, and can also optionally abandoning
-+ *  the array part, 'migrating' array entries into the beginning of the
-+ *  new entry part.  Arguments are not validated here, so e.g. new_h_size
-+ *  MUST be a valid prime.
-+ *
-+ *  There is no support for in-place reallocation or just compacting keys
-+ *  without resizing the property allocation.  This is intentional to keep
-+ *  code size minimal.
-+ *
-+ *  The implementation is relatively straightforward, except for the array
-+ *  abandonment process.  Array abandonment requires that new string keys
-+ *  are interned, which may trigger GC.  All keys interned so far must be
-+ *  reachable for GC at all times; valstack is used for that now.
-+ *
-+ *  Also, a GC triggered during this reallocation process must not interfere
-+ *  with the object being resized.  This is currently controlled by using
-+ *  heap->mark_and_sweep_base_flags to indicate that no finalizers will be
-+ *  executed (as they can affect ANY object) and no objects are compacted
-+ *  (it would suffice to protect this particular object only, though).
-+ *
-+ *  Note: a non-checked variant would be nice but is a bit tricky to
-+ *  implement for the array abandonment process.  It's easy for
-+ *  everything else.
-+ *
-+ *  Note: because we need to potentially resize the valstack (as part
-+ *  of abandoning the array part), any tval pointers to the valstack
-+ *  will become invalid after this call.
-+ */
-+
-+DUK_LOCAL
-+void duk__realloc_props(duk_hthread *thr,
-+                        duk_hobject *obj,
-+                        duk_uint32_t new_e_size,
-+                        duk_uint32_t new_a_size,
-+                        duk_uint32_t new_h_size,
-+                        duk_bool_t abandon_array) {
-+	duk_context *ctx = (duk_context *) thr;
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	duk_small_uint_t prev_mark_and_sweep_base_flags;
-+#endif
-+	duk_uint32_t new_alloc_size;
-+	duk_uint32_t new_e_size_adjusted;
-+	duk_uint8_t *new_p;
-+	duk_hstring **new_e_k;
-+	duk_propvalue *new_e_pv;
-+	duk_uint8_t *new_e_f;
-+	duk_tval *new_a;
-+	duk_uint32_t *new_h;
-+	duk_uint32_t new_e_next;
-+	duk_uint_fast32_t i;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(!abandon_array || new_a_size == 0);  /* if abandon_array, new_a_size must be 0 */
-+	DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL || (DUK_HOBJECT_GET_ESIZE(obj) == 0 && DUK_HOBJECT_GET_ASIZE(obj) == 0));
-+	DUK_ASSERT(new_h_size == 0 || new_h_size >= new_e_size);  /* required to guarantee success of rehashing,
-+	                                                           * intentionally use unadjusted new_e_size
-+	                                                           */
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/*
-+	 *  Pre resize assertions.
-+	 */
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	/* XXX: pre-checks (such as no duplicate keys) */
-+#endif
-+
-+	/*
-+	 *  For property layout 1, tweak e_size to ensure that the whole entry
-+	 *  part (key + val + flags) is a suitable multiple for alignment
-+	 *  (platform specific).
-+	 *
-+	 *  Property layout 2 does not require this tweaking and is preferred
-+	 *  on low RAM platforms requiring alignment.
-+	 */
-+
-+#if defined(DUK_USE_HOBJECT_LAYOUT_2) || defined(DUK_USE_HOBJECT_LAYOUT_3)
-+	DUK_DDD(DUK_DDDPRINT("using layout 2 or 3, no need to pad e_size: %ld", (long) new_e_size));
-+	new_e_size_adjusted = new_e_size;
-+#elif defined(DUK_USE_HOBJECT_LAYOUT_1) && (DUK_HOBJECT_ALIGN_TARGET == 1)
-+	DUK_DDD(DUK_DDDPRINT("using layout 1, but no need to pad e_size: %ld", (long) new_e_size));
-+	new_e_size_adjusted = new_e_size;
-+#elif defined(DUK_USE_HOBJECT_LAYOUT_1) && ((DUK_HOBJECT_ALIGN_TARGET == 4) || (DUK_HOBJECT_ALIGN_TARGET == 8))
-+	new_e_size_adjusted = (new_e_size + DUK_HOBJECT_ALIGN_TARGET - 1) & (~(DUK_HOBJECT_ALIGN_TARGET - 1));
-+	DUK_DDD(DUK_DDDPRINT("using layout 1, and alignment target is %ld, adjusted e_size: %ld -> %ld",
-+	                     (long) DUK_HOBJECT_ALIGN_TARGET, (long) new_e_size, (long) new_e_size_adjusted));
-+	DUK_ASSERT(new_e_size_adjusted >= new_e_size);
-+#else
-+#error invalid hobject layout defines
-+#endif
-+
-+	/*
-+	 *  Debug logging after adjustment.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("attempt to resize hobject %p props (%ld -> %ld bytes), from {p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld} to "
-+	                     "{e_size=%ld,a_size=%ld,h_size=%ld}, abandon_array=%ld, unadjusted new_e_size=%ld",
-+	                     (void *) obj,
-+	                     (long) DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),
-+	                                                       DUK_HOBJECT_GET_ASIZE(obj),
-+	                                                       DUK_HOBJECT_GET_HSIZE(obj)),
-+	                     (long) DUK_HOBJECT_P_COMPUTE_SIZE(new_e_size_adjusted, new_a_size, new_h_size),
-+	                     (void *) DUK_HOBJECT_GET_PROPS(thr->heap, obj),
-+	                     (long) DUK_HOBJECT_GET_ESIZE(obj),
-+	                     (long) DUK_HOBJECT_GET_ENEXT(obj),
-+	                     (long) DUK_HOBJECT_GET_ASIZE(obj),
-+	                     (long) DUK_HOBJECT_GET_HSIZE(obj),
-+	                     (long) new_e_size_adjusted,
-+	                     (long) new_a_size,
-+	                     (long) new_h_size,
-+	                     (long) abandon_array,
-+	                     (long) new_e_size));
-+
-+	/*
-+	 *  Property count check.  This is the only point where we ensure that
-+	 *  we don't get more (allocated) property space that we can handle.
-+	 *  There aren't hard limits as such, but some algorithms fail (e.g.
-+	 *  finding next higher prime, selecting hash part size) if we get too
-+	 *  close to the 4G property limit.
-+	 *
-+	 *  Since this works based on allocation size (not actually used size),
-+	 *  the limit is a bit approximate but good enough in practice.
-+	 */
-+
-+	if (new_e_size_adjusted + new_a_size > DUK_HOBJECT_MAX_PROPERTIES) {
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_OBJECT_PROPERTY_LIMIT);
-+	}
-+
-+	/*
-+	 *  Compute new alloc size and alloc new area.
-+	 *
-+	 *  The new area is allocated as a dynamic buffer and placed into the
-+	 *  valstack for reachability.  The actual buffer is then detached at
-+	 *  the end.
-+	 *
-+	 *  Note: heap_mark_and_sweep_base_flags are altered here to ensure
-+	 *  no-one touches this object while we're resizing and rehashing it.
-+	 *  The flags must be reset on every exit path after it.  Finalizers
-+	 *  and compaction is prevented currently for all objects while it
-+	 *  would be enough to restrict it only for the current object.
-+	 */
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	prev_mark_and_sweep_base_flags = thr->heap->mark_and_sweep_base_flags;
-+	thr->heap->mark_and_sweep_base_flags |=
-+                DUK_MS_FLAG_NO_FINALIZERS |         /* avoid attempts to add/remove object keys */
-+	        DUK_MS_FLAG_NO_OBJECT_COMPACTION;   /* avoid attempt to compact the current object */
-+#endif
-+
-+	new_alloc_size = DUK_HOBJECT_P_COMPUTE_SIZE(new_e_size_adjusted, new_a_size, new_h_size);
-+	DUK_DDD(DUK_DDDPRINT("new hobject allocation size is %ld", (long) new_alloc_size));
-+	if (new_alloc_size == 0) {
-+		/* for zero size, don't push anything on valstack */
-+		DUK_ASSERT(new_e_size_adjusted == 0);
-+		DUK_ASSERT(new_a_size == 0);
-+		DUK_ASSERT(new_h_size == 0);
-+		new_p = NULL;
-+	} else {
-+		/* This may trigger mark-and-sweep with arbitrary side effects,
-+		 * including an attempted resize of the object we're resizing,
-+		 * executing a finalizer which may add or remove properties of
-+		 * the object we're resizing etc.
-+		 */
-+
-+		/* Note: buffer is dynamic so that we can 'steal' the actual
-+		 * allocation later.
-+		 */
-+
-+		new_p = (duk_uint8_t *) duk_push_dynamic_buffer(ctx, new_alloc_size);  /* errors out if out of memory */
-+		DUK_ASSERT(new_p != NULL);  /* since new_alloc_size > 0 */
-+	}
-+
-+	/* Set up pointers to the new property area: this is hidden behind a macro
-+	 * because it is memory layout specific.
-+	 */
-+	DUK_HOBJECT_P_SET_REALLOC_PTRS(new_p, new_e_k, new_e_pv, new_e_f, new_a, new_h,
-+	                               new_e_size_adjusted, new_a_size, new_h_size);
-+	DUK_UNREF(new_h);  /* happens when hash part dropped */
-+	new_e_next = 0;
-+
-+	/* if new_p == NULL, all of these pointers are NULL */
-+	DUK_ASSERT((new_p != NULL) ||
-+	           (new_e_k == NULL && new_e_pv == NULL && new_e_f == NULL &&
-+	            new_a == NULL && new_h == NULL));
-+
-+	DUK_DDD(DUK_DDDPRINT("new alloc size %ld, new_e_k=%p, new_e_pv=%p, new_e_f=%p, new_a=%p, new_h=%p",
-+	                     (long) new_alloc_size, (void *) new_e_k, (void *) new_e_pv, (void *) new_e_f,
-+	                     (void *) new_a, (void *) new_h));
-+
-+	/*
-+	 *  Migrate array to start of entries if requested.
-+	 *
-+	 *  Note: from an enumeration perspective the order of entry keys matters.
-+	 *  Array keys should appear wherever they appeared before the array abandon
-+	 *  operation.
-+	 */
-+
-+	if (abandon_array) {
-+		/*
-+		 *  Note: assuming new_a_size == 0, and that entry part contains
-+		 *  no conflicting keys, refcounts do not need to be adjusted for
-+		 *  the values, as they remain exactly the same.
-+		 *
-+		 *  The keys, however, need to be interned, incref'd, and be
-+		 *  reachable for GC.  Any intern attempt may trigger a GC and
-+		 *  claim any non-reachable strings, so every key must be reachable
-+		 *  at all times.
-+		 *
-+		 *  A longjmp must not occur here, as the new_p allocation would
-+		 *  be freed without these keys being decref'd, hence the messy
-+		 *  decref handling if intern fails.
-+		 */
-+		DUK_ASSERT(new_a_size == 0);
-+
-+		for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) {
-+			duk_tval *tv1;
-+			duk_tval *tv2;
-+			duk_hstring *key;
-+
-+			DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
-+
-+			tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
-+			if (DUK_TVAL_IS_UNDEFINED_UNUSED(tv1)) {
-+				continue;
-+			}
-+
-+			DUK_ASSERT(new_p != NULL && new_e_k != NULL &&
-+			           new_e_pv != NULL && new_e_f != NULL);
-+
-+			/*
-+			 *  Intern key via the valstack to ensure reachability behaves
-+			 *  properly.  We must avoid longjmp's here so use non-checked
-+			 *  primitives.
-+			 *
-+			 *  Note: duk_check_stack() potentially reallocs the valstack,
-+			 *  invalidating any duk_tval pointers to valstack.  Callers
-+			 *  must be careful.
-+			 */
-+
-+			/* never shrinks; auto-adds DUK_VALSTACK_INTERNAL_EXTRA, which is generous */
-+			if (!duk_check_stack(ctx, 1)) {
-+				goto abandon_error;
-+			}
-+			DUK_ASSERT_VALSTACK_SPACE(thr, 1);
-+			key = duk_heap_string_intern_u32(thr->heap, i);
-+			if (!key) {
-+				goto abandon_error;
-+			}
-+			duk_push_hstring(ctx, key);  /* keep key reachable for GC etc; guaranteed not to fail */
-+
-+			/* key is now reachable in the valstack */
-+
-+			DUK_HSTRING_INCREF(thr, key);   /* second incref for the entry reference */
-+			new_e_k[new_e_next] = key;
-+			tv2 = &new_e_pv[new_e_next].v;  /* array entries are all plain values */
-+			DUK_TVAL_SET_TVAL(tv2, tv1);
-+			new_e_f[new_e_next] = DUK_PROPDESC_FLAG_WRITABLE |
-+			                      DUK_PROPDESC_FLAG_ENUMERABLE |
-+			                      DUK_PROPDESC_FLAG_CONFIGURABLE;
-+			new_e_next++;
-+
-+			/* Note: new_e_next matches pushed temp key count, and nothing can
-+			 * fail above between the push and this point.
-+			 */
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("abandon array: pop %ld key temps from valstack", (long) new_e_next));
-+		duk_pop_n(ctx, new_e_next);
-+	}
-+
-+	/*
-+	 *  Copy keys and values in the entry part (compacting them at the same time).
-+	 */
-+
-+	for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
-+		duk_hstring *key;
-+
-+		DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
-+
-+		key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
-+		if (!key) {
-+			continue;
-+		}
-+
-+		DUK_ASSERT(new_p != NULL && new_e_k != NULL &&
-+		           new_e_pv != NULL && new_e_f != NULL);
-+
-+		new_e_k[new_e_next] = key;
-+		new_e_pv[new_e_next] = DUK_HOBJECT_E_GET_VALUE(thr->heap, obj, i);
-+		new_e_f[new_e_next] = DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, i);
-+		new_e_next++;
-+	}
-+	/* the entries [new_e_next, new_e_size_adjusted[ are left uninitialized on purpose (ok, not gc reachable) */
-+
-+	/*
-+	 *  Copy array elements to new array part.
-+	 */
-+
-+	if (new_a_size > DUK_HOBJECT_GET_ASIZE(obj)) {
-+		/* copy existing entries as is */
-+		DUK_ASSERT(new_p != NULL && new_a != NULL);
-+		if (DUK_HOBJECT_GET_ASIZE(obj) > 0) {
-+			/* Avoid zero copy with an invalid pointer.  If obj->p is NULL,
-+			 * the 'new_a' pointer will be invalid which is not allowed even
-+			 * when copy size is zero.
-+			 */
-+			DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
-+			DUK_ASSERT(DUK_HOBJECT_GET_ASIZE(obj) > 0);
-+			DUK_MEMCPY((void *) new_a, (void *) DUK_HOBJECT_A_GET_BASE(thr->heap, obj), sizeof(duk_tval) * DUK_HOBJECT_GET_ASIZE(obj));
-+		}
-+
-+		/* fill new entries with -unused- (required, gc reachable) */
-+		for (i = DUK_HOBJECT_GET_ASIZE(obj); i < new_a_size; i++) {
-+			duk_tval *tv = &new_a[i];
-+			DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+		}
-+	} else {
-+#ifdef DUK_USE_ASSERTIONS
-+		/* caller must have decref'd values above new_a_size (if that is necessary) */
-+		if (!abandon_array) {
-+			for (i = new_a_size; i < DUK_HOBJECT_GET_ASIZE(obj); i++) {
-+				duk_tval *tv;
-+				tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
-+
-+				/* current assertion is quite strong: decref's and set to unused */
-+				DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv));
-+			}
-+		}
-+#endif
-+		if (new_a_size > 0) {
-+			/* Avoid zero copy with an invalid pointer.  If obj->p is NULL,
-+			 * the 'new_a' pointer will be invalid which is not allowed even
-+			 * when copy size is zero.
-+			 */
-+			DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
-+			DUK_ASSERT(new_a_size > 0);
-+			DUK_MEMCPY((void *) new_a, (void *) DUK_HOBJECT_A_GET_BASE(thr->heap, obj), sizeof(duk_tval) * new_a_size);
-+		}
-+	}
-+
-+	/*
-+	 *  Rebuild the hash part always from scratch (guaranteed to finish).
-+	 *
-+	 *  Any resize of hash part requires rehashing.  In addition, by rehashing
-+	 *  get rid of any elements marked deleted (DUK__HASH_DELETED) which is critical
-+	 *  to ensuring the hash part never fills up.
-+	 */
-+
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	if (DUK_UNLIKELY(new_h_size > 0)) {
-+		DUK_ASSERT(new_h != NULL);
-+
-+		/* fill new_h with u32 0xff = UNUSED */
-+		DUK_ASSERT(DUK_HOBJECT_GET_PROPS(thr->heap, obj) != NULL);
-+		DUK_ASSERT(new_h_size > 0);
-+		DUK_MEMSET(new_h, 0xff, sizeof(duk_uint32_t) * new_h_size);
-+
-+		DUK_ASSERT(new_e_next <= new_h_size);  /* equality not actually possible */
-+		for (i = 0; i < new_e_next; i++) {
-+			duk_hstring *key = new_e_k[i];
-+			duk_uint32_t j, step;
-+
-+			DUK_ASSERT(key != NULL);
-+			j = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), new_h_size);
-+			step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key));
-+
-+			for (;;) {
-+				DUK_ASSERT(new_h[j] != DUK__HASH_DELETED);  /* should never happen */
-+				if (new_h[j] == DUK__HASH_UNUSED) {
-+					DUK_DDD(DUK_DDDPRINT("rebuild hit %ld -> %ld", (long) j, (long) i));
-+					new_h[j] = i;
-+					break;
-+				}
-+				DUK_DDD(DUK_DDDPRINT("rebuild miss %ld, step %ld", (long) j, (long) step));
-+				j = (j + step) % new_h_size;
-+
-+				/* guaranteed to finish */
-+				DUK_ASSERT(j != (duk_uint32_t) DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), new_h_size));
-+			}
-+		}
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("no hash part, no rehash"));
-+	}
-+#endif  /* DUK_USE_HOBJECT_HASH_PART */
-+
-+	/*
-+	 *  Nice debug log.
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("resized hobject %p props (%ld -> %ld bytes), from {p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld} to "
-+	                   "{p=%p,e_size=%ld,e_next=%ld,a_size=%ld,h_size=%ld}, abandon_array=%ld, unadjusted new_e_size=%ld",
-+	                   (void *) obj,
-+	                   (long) DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE(obj),
-+	                                                     DUK_HOBJECT_GET_ASIZE(obj),
-+	                                                     DUK_HOBJECT_GET_HSIZE(obj)),
-+	                   (long) new_alloc_size,
-+	                   (void *) DUK_HOBJECT_GET_PROPS(thr->heap, obj),
-+	                   (long) DUK_HOBJECT_GET_ESIZE(obj),
-+	                   (long) DUK_HOBJECT_GET_ENEXT(obj),
-+	                   (long) DUK_HOBJECT_GET_ASIZE(obj),
-+	                   (long) DUK_HOBJECT_GET_HSIZE(obj),
-+	                   (void *) new_p,
-+	                   (long) new_e_size_adjusted,
-+	                   (long) new_e_next,
-+	                   (long) new_a_size,
-+	                   (long) new_h_size,
-+	                   (long) abandon_array,
-+	                   (long) new_e_size));
-+
-+	/*
-+	 *  All done, switch properties ('p') allocation to new one.
-+	 */
-+
-+	DUK_FREE(thr->heap, DUK_HOBJECT_GET_PROPS(thr->heap, obj));  /* NULL obj->p is OK */
-+	DUK_HOBJECT_SET_PROPS(thr->heap, obj, new_p);
-+	DUK_HOBJECT_SET_ESIZE(obj, new_e_size_adjusted);
-+	DUK_HOBJECT_SET_ENEXT(obj, new_e_next);
-+	DUK_HOBJECT_SET_ASIZE(obj, new_a_size);
-+	DUK_HOBJECT_SET_HSIZE(obj, new_h_size);
-+
-+	if (new_p) {
-+		/*
-+		 *  Detach actual buffer from dynamic buffer in valstack, and
-+		 *  pop it from the stack.
-+		 *
-+		 *  XXX: the buffer object is certainly not reachable at this point,
-+		 *  so it would be nice to free it forcibly even with only
-+		 *  mark-and-sweep enabled.  Not a big issue though.
-+		 */
-+		duk_hbuffer_dynamic *buf;
-+		DUK_ASSERT(new_alloc_size > 0);
-+		DUK_ASSERT(duk_is_buffer(ctx, -1));
-+		buf = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, -1);
-+		DUK_ASSERT(buf != NULL);
-+		DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(buf));
-+		DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(thr->heap, buf);
-+		DUK_HBUFFER_DYNAMIC_SET_SIZE(buf, 0);  /* these size resets are not strictly necessary, but nice for consistency */
-+		DUK_HBUFFER_DYNAMIC_SET_ALLOC_SIZE(buf, 0);
-+		duk_pop(ctx);
-+	} else {
-+		DUK_ASSERT(new_alloc_size == 0);
-+		/* no need to pop, nothing was pushed */
-+	}
-+
-+	/* clear array part flag only after switching */
-+	if (abandon_array) {
-+		DUK_HOBJECT_CLEAR_ARRAY_PART(obj);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("resize result: %!O", (duk_heaphdr *) obj));
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
-+#endif
-+
-+	/*
-+	 *  Post resize assertions.
-+	 */
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	/* XXX: post-checks (such as no duplicate keys) */
-+#endif
-+	return;
-+
-+	/*
-+	 *  Abandon array failed, need to decref keys already inserted
-+	 *  into the beginning of new_e_k before unwinding valstack.
-+	 */
-+
-+ abandon_error:
-+	DUK_D(DUK_DPRINT("hobject resize failed during abandon array, decref keys"));
-+	i = new_e_next;
-+	while (i > 0) {
-+		i--;
-+		DUK_ASSERT(new_e_k != NULL);
-+		DUK_ASSERT(new_e_k[i] != NULL);
-+		DUK_HSTRING_DECREF(thr, new_e_k[i]);
-+	}
-+
-+#ifdef DUK_USE_MARK_AND_SWEEP
-+	thr->heap->mark_and_sweep_base_flags = prev_mark_and_sweep_base_flags;
-+#endif
-+
-+	DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_OBJECT_RESIZE_FAILED);
-+}
-+
-+/*
-+ *  Helpers to resize properties allocation on specific needs.
-+ */
-+
-+/* Grow entry part allocation for one additional entry. */
-+DUK_LOCAL void duk__grow_props_for_new_entry_item(duk_hthread *thr, duk_hobject *obj) {
-+	duk_uint32_t old_e_used;  /* actually used, non-NULL entries */
-+	duk_uint32_t new_e_size;
-+	duk_uint32_t new_a_size;
-+	duk_uint32_t new_h_size;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+
-+	/* Duktape 0.11.0 and prior tried to optimize the resize by not
-+	 * counting the number of actually used keys prior to the resize.
-+	 * This worked mostly well but also caused weird leak-like behavior
-+	 * as in: test-bug-object-prop-alloc-unbounded.js.  So, now we count
-+	 * the keys explicitly to compute the new entry part size.
-+	 */
-+
-+	old_e_used = duk__count_used_e_keys(thr, obj);
-+	new_e_size = old_e_used + duk__get_min_grow_e(old_e_used);
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	new_h_size = duk__get_default_h_size(new_e_size);
-+#else
-+	new_h_size = 0;
-+#endif
-+	new_a_size = DUK_HOBJECT_GET_ASIZE(obj);
-+	DUK_ASSERT(new_e_size >= old_e_used + 1);  /* duk__get_min_grow_e() is always >= 1 */
-+
-+	duk__realloc_props(thr, obj, new_e_size, new_a_size, new_h_size, 0);
-+}
-+
-+/* Grow array part for a new highest array index. */
-+DUK_LOCAL void duk__grow_props_for_array_item(duk_hthread *thr, duk_hobject *obj, duk_uint32_t highest_arr_idx) {
-+	duk_uint32_t new_e_size;
-+	duk_uint32_t new_a_size;
-+	duk_uint32_t new_h_size;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(highest_arr_idx >= DUK_HOBJECT_GET_ASIZE(obj));
-+
-+	/* minimum new length is highest_arr_idx + 1 */
-+
-+	new_e_size = DUK_HOBJECT_GET_ESIZE(obj);
-+	new_h_size = DUK_HOBJECT_GET_HSIZE(obj);
-+	new_a_size = highest_arr_idx + duk__get_min_grow_a(highest_arr_idx);
-+	DUK_ASSERT(new_a_size >= highest_arr_idx + 1);  /* duk__get_min_grow_a() is always >= 1 */
-+
-+	duk__realloc_props(thr, obj, new_e_size, new_a_size, new_h_size, 0);
-+}
-+
-+/* Abandon array part, moving array entries into entries part.
-+ * This requires a props resize, which is a heavy operation.
-+ * We also compact the entries part while we're at it, although
-+ * this is not strictly required.
-+ */
-+DUK_LOCAL void duk__abandon_array_checked(duk_hthread *thr, duk_hobject *obj) {
-+	duk_uint32_t new_e_size;
-+	duk_uint32_t new_a_size;
-+	duk_uint32_t new_h_size;
-+	duk_uint32_t e_used;  /* actually used, non-NULL keys */
-+	duk_uint32_t a_used;
-+	duk_uint32_t a_size;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+
-+	e_used = duk__count_used_e_keys(thr, obj);
-+	duk__compute_a_stats(thr, obj, &a_used, &a_size);
-+
-+	/*
-+	 *  Must guarantee all actually used array entries will fit into
-+	 *  new entry part.  Add one growth step to ensure we don't run out
-+	 *  of space right away.
-+	 */
-+
-+	new_e_size = e_used + a_used;
-+	new_e_size = new_e_size + duk__get_min_grow_e(new_e_size);
-+	new_a_size = 0;
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	new_h_size = duk__get_default_h_size(new_e_size);
-+#else
-+	new_h_size = 0;
-+#endif
-+
-+	DUK_DD(DUK_DDPRINT("abandon array part for hobject %p, "
-+	                   "array stats before: e_used=%ld, a_used=%ld, a_size=%ld; "
-+	                   "resize to e_size=%ld, a_size=%ld, h_size=%ld",
-+	                   (void *) obj, (long) e_used, (long) a_used, (long) a_size,
-+	                   (long) new_e_size, (long) new_a_size, (long) new_h_size));
-+
-+	duk__realloc_props(thr, obj, new_e_size, new_a_size, new_h_size, 1);
-+}
-+
-+/*
-+ *  Compact an object.  Minimizes allocation size for objects which are
-+ *  not likely to be extended.  This is useful for internal and non-
-+ *  extensible objects, but can also be called for non-extensible objects.
-+ *  May abandon the array part if it is computed to be too sparse.
-+ *
-+ *  This call is relatively expensive, as it needs to scan both the
-+ *  entries and the array part.
-+ *
-+ *  The call may fail due to allocation error.
-+ */
-+
-+DUK_INTERNAL void duk_hobject_compact_props(duk_hthread *thr, duk_hobject *obj) {
-+	duk_uint32_t e_size;       /* currently used -> new size */
-+	duk_uint32_t a_size;       /* currently required */
-+	duk_uint32_t a_used;       /* actually used */
-+	duk_uint32_t h_size;
-+	duk_bool_t abandon_array;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+
-+	e_size = duk__count_used_e_keys(thr, obj);
-+	duk__compute_a_stats(thr, obj, &a_used, &a_size);
-+
-+	DUK_DD(DUK_DDPRINT("compacting hobject, used e keys %ld, used a keys %ld, min a size %ld, "
-+	                   "resized array density would be: %ld/%ld = %lf",
-+	                   (long) e_size, (long) a_used, (long) a_size,
-+	                   (long) a_used, (long) a_size,
-+	                   (double) a_used / (double) a_size));
-+
-+	if (duk__abandon_array_density_check(a_used, a_size)) {
-+		DUK_DD(DUK_DDPRINT("decided to abandon array during compaction, a_used=%ld, a_size=%ld",
-+		                   (long) a_used, (long) a_size));
-+		abandon_array = 1;
-+		e_size += a_used;
-+		a_size = 0;
-+	} else {
-+		DUK_DD(DUK_DDPRINT("decided to keep array during compaction"));
-+		abandon_array = 0;
-+	}
-+
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	if (e_size >= DUK_HOBJECT_E_USE_HASH_LIMIT) {
-+		h_size = duk__get_default_h_size(e_size);
-+	} else {
-+		h_size = 0;
-+	}
-+#else
-+	h_size = 0;
-+#endif
-+
-+	DUK_DD(DUK_DDPRINT("compacting hobject -> new e_size %ld, new a_size=%ld, new h_size=%ld, abandon_array=%ld",
-+	                   (long) e_size, (long) a_size, (long) h_size, (long) abandon_array));
-+
-+	duk__realloc_props(thr, obj, e_size, a_size, h_size, abandon_array);
-+}
-+
-+/*
-+ *  Find an existing key from entry part either by linear scan or by
-+ *  using the hash index (if it exists).
-+ *
-+ *  Sets entry index (and possibly the hash index) to output variables,
-+ *  which allows the caller to update the entry and hash entries in-place.
-+ *  If entry is not found, both values are set to -1.  If entry is found
-+ *  but there is no hash part, h_idx is set to -1.
-+ */
-+
-+DUK_INTERNAL void duk_hobject_find_existing_entry(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *e_idx, duk_int_t *h_idx) {
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(e_idx != NULL);
-+	DUK_ASSERT(h_idx != NULL);
-+	DUK_UNREF(heap);
-+
-+	if (DUK_LIKELY(DUK_HOBJECT_GET_HSIZE(obj) == 0))
-+	{
-+		/* Linear scan: more likely because most objects are small.
-+		 * This is an important fast path.
-+		 *
-+		 * XXX: this might be worth inlining for property lookups.
-+		 */
-+		duk_uint_fast32_t i;
-+		duk_uint_fast32_t n;
-+		duk_hstring **h_keys_base;
-+		DUK_DDD(DUK_DDDPRINT("duk_hobject_find_existing_entry() using linear scan for lookup"));
-+
-+		h_keys_base = DUK_HOBJECT_E_GET_KEY_BASE(heap, obj);
-+		n = DUK_HOBJECT_GET_ENEXT(obj);
-+		for (i = 0; i < n; i++) {
-+			if (h_keys_base[i] == key) {
-+				*e_idx = i;
-+				*h_idx = -1;
-+				return;
-+			}
-+		}
-+	}
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	else
-+	{
-+		/* hash lookup */
-+		duk_uint32_t n;
-+		duk_uint32_t i, step;
-+		duk_uint32_t *h_base;
-+
-+		DUK_DDD(DUK_DDDPRINT("duk_hobject_find_existing_entry() using hash part for lookup"));
-+
-+		h_base = DUK_HOBJECT_H_GET_BASE(heap, obj);
-+		n = DUK_HOBJECT_GET_HSIZE(obj);
-+		i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), n);
-+		step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key));
-+
-+		for (;;) {
-+			duk_uint32_t t;
-+
-+			DUK_ASSERT_DISABLE(i >= 0);  /* unsigned */
-+			DUK_ASSERT(i < DUK_HOBJECT_GET_HSIZE(obj));
-+			t = h_base[i];
-+			DUK_ASSERT(t == DUK__HASH_UNUSED || t == DUK__HASH_DELETED ||
-+			           (t < DUK_HOBJECT_GET_ESIZE(obj)));  /* t >= 0 always true, unsigned */
-+
-+			if (t == DUK__HASH_UNUSED) {
-+				break;
-+			} else if (t == DUK__HASH_DELETED) {
-+				DUK_DDD(DUK_DDDPRINT("lookup miss (deleted) i=%ld, t=%ld",
-+				                     (long) i, (long) t));
-+			} else {
-+				DUK_ASSERT(t < DUK_HOBJECT_GET_ESIZE(obj));
-+				if (DUK_HOBJECT_E_GET_KEY(heap, obj, t) == key) {
-+					DUK_DDD(DUK_DDDPRINT("lookup hit i=%ld, t=%ld -> key %p",
-+					                     (long) i, (long) t, (void *) key));
-+					*e_idx = t;
-+					*h_idx = i;
-+					return;
-+				}
-+				DUK_DDD(DUK_DDDPRINT("lookup miss i=%ld, t=%ld",
-+				                     (long) i, (long) t));
-+			}
-+			i = (i + step) % n;
-+
-+			/* guaranteed to finish, as hash is never full */
-+			DUK_ASSERT(i != (duk_uint32_t) DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), n));
-+		}
-+	}
-+#endif  /* DUK_USE_HOBJECT_HASH_PART */
-+
-+	/* not found */
-+	*e_idx = -1;
-+	*h_idx = -1;
-+}
-+
-+/* For internal use: get non-accessor entry value */
-+DUK_INTERNAL duk_tval *duk_hobject_find_existing_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_hstring *key) {
-+	duk_int_t e_idx;
-+	duk_int_t h_idx;
-+
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_UNREF(heap);
-+
-+	duk_hobject_find_existing_entry(heap, obj, key, &e_idx, &h_idx);
-+	if (e_idx >= 0 && !DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx)) {
-+		return DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx);
-+	} else {
-+		return NULL;
-+	}
-+}
-+
-+/* For internal use: get non-accessor entry value and attributes */
-+DUK_INTERNAL duk_tval *duk_hobject_find_existing_entry_tval_ptr_and_attrs(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *out_attrs) {
-+	duk_int_t e_idx;
-+	duk_int_t h_idx;
-+
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(out_attrs != NULL);
-+	DUK_UNREF(heap);
-+
-+	duk_hobject_find_existing_entry(heap, obj, key, &e_idx, &h_idx);
-+	if (e_idx >= 0 && !DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx)) {
-+		*out_attrs = DUK_HOBJECT_E_GET_FLAGS(heap, obj, e_idx);
-+		return DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx);
-+	} else {
-+		*out_attrs = 0;
-+		return NULL;
-+	}
-+}
-+
-+/* For internal use: get array part value */
-+DUK_INTERNAL duk_tval *duk_hobject_find_existing_array_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_uarridx_t i) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(obj != NULL);
-+	DUK_UNREF(heap);
-+
-+	if (!DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
-+		return NULL;
-+	}
-+	if (i >= DUK_HOBJECT_GET_ASIZE(obj)) {
-+		return NULL;
-+	}
-+	tv = DUK_HOBJECT_A_GET_VALUE_PTR(heap, obj, i);
-+	return tv;
-+}
-+
-+/*
-+ *  Allocate and initialize a new entry, resizing the properties allocation
-+ *  if necessary.  Returns entry index (e_idx) or throws an error if alloc fails.
-+ *
-+ *  Sets the key of the entry (increasing the key's refcount), and updates
-+ *  the hash part if it exists.  Caller must set value and flags, and update
-+ *  the entry value refcount.  A decref for the previous value is not necessary.
-+ */
-+
-+DUK_LOCAL duk_bool_t duk__alloc_entry_checked(duk_hthread *thr, duk_hobject *obj, duk_hstring *key) {
-+	duk_uint32_t idx;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(obj) <= DUK_HOBJECT_GET_ESIZE(obj));
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	/* key must not already exist in entry part */
-+	{
-+		duk_uint_fast32_t i;
-+		for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
-+			DUK_ASSERT(DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i) != key);
-+		}
-+	}
-+#endif
-+
-+	if (DUK_HOBJECT_GET_ENEXT(obj) >= DUK_HOBJECT_GET_ESIZE(obj)) {
-+		/* only need to guarantee 1 more slot, but allocation growth is in chunks */
-+		DUK_DDD(DUK_DDDPRINT("entry part full, allocate space for one more entry"));
-+		duk__grow_props_for_new_entry_item(thr, obj);
-+	}
-+	DUK_ASSERT(DUK_HOBJECT_GET_ENEXT(obj) < DUK_HOBJECT_GET_ESIZE(obj));
-+	idx = DUK_HOBJECT_POSTINC_ENEXT(obj);
-+
-+	/* previous value is assumed to be garbage, so don't touch it */
-+	DUK_HOBJECT_E_SET_KEY(thr->heap, obj, idx, key);
-+	DUK_HSTRING_INCREF(thr, key);
-+
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+	if (DUK_UNLIKELY(DUK_HOBJECT_GET_HSIZE(obj) > 0)) {
-+		duk_uint32_t n;
-+		duk_uint32_t i, step;
-+		duk_uint32_t *h_base = DUK_HOBJECT_H_GET_BASE(thr->heap, obj);
-+
-+		n = DUK_HOBJECT_GET_HSIZE(obj);
-+		i = DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), n);
-+		step = DUK__HASH_PROBE_STEP(DUK_HSTRING_GET_HASH(key));
-+
-+		for (;;) {
-+			duk_uint32_t t = h_base[i];
-+			if (t == DUK__HASH_UNUSED || t == DUK__HASH_DELETED) {
-+				DUK_DDD(DUK_DDDPRINT("duk__alloc_entry_checked() inserted key into hash part, %ld -> %ld",
-+				                     (long) i, (long) idx));
-+				DUK_ASSERT_DISABLE(i >= 0);  /* unsigned */
-+				DUK_ASSERT(i < DUK_HOBJECT_GET_HSIZE(obj));
-+				DUK_ASSERT_DISABLE(idx >= 0);
-+				DUK_ASSERT(idx < DUK_HOBJECT_GET_ESIZE(obj));
-+				h_base[i] = idx;
-+				break;
-+			}
-+			DUK_DDD(DUK_DDDPRINT("duk__alloc_entry_checked() miss %ld", (long) i));
-+			i = (i + step) % n;
-+
-+			/* guaranteed to find an empty slot */
-+			DUK_ASSERT(i != (duk_uint32_t) DUK__HASH_INITIAL(DUK_HSTRING_GET_HASH(key), DUK_HOBJECT_GET_HSIZE(obj)));
-+		}
-+	}
-+#endif  /* DUK_USE_HOBJECT_HASH_PART */
-+
-+	/* Note: we could return the hash index here too, but it's not
-+	 * needed right now.
-+	 */
-+
-+	DUK_ASSERT_DISABLE(idx >= 0);
-+	DUK_ASSERT(idx < DUK_HOBJECT_GET_ESIZE(obj));
-+	DUK_ASSERT(idx < DUK_HOBJECT_GET_ENEXT(obj));
-+	return idx;
-+}
-+
-+/*
-+ *  Object internal value
-+ *
-+ *  Returned value is guaranteed to be reachable / incref'd, caller does not need
-+ *  to incref OR decref.  No proxies or accessors are invoked, no prototype walk.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_get_internal_value(duk_heap *heap, duk_hobject *obj, duk_tval *tv_out) {
-+	duk_int_t e_idx;
-+	duk_int_t h_idx;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(tv_out != NULL);
-+
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(tv_out);
-+
-+	/* always in entry part, no need to look up parents etc */
-+	duk_hobject_find_existing_entry(heap, obj, DUK_HEAP_STRING_INT_VALUE(heap), &e_idx, &h_idx);
-+	if (e_idx >= 0) {
-+		DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap, obj, e_idx));
-+		DUK_TVAL_SET_TVAL(tv_out, DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap, obj, e_idx));
-+		return 1;
-+	}
-+	return 0;
-+}
-+
-+DUK_INTERNAL duk_hstring *duk_hobject_get_internal_value_string(duk_heap *heap, duk_hobject *obj) {
-+	duk_tval tv;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+
-+	if (duk_hobject_get_internal_value(heap, obj, &tv)) {
-+		duk_hstring *h;
-+		DUK_ASSERT(DUK_TVAL_IS_STRING(&tv));
-+		h = DUK_TVAL_GET_STRING(&tv);
-+		return h;
-+	}
-+
-+	return NULL;
-+}
-+
-+DUK_INTERNAL duk_hbuffer *duk_hobject_get_internal_value_buffer(duk_heap *heap, duk_hobject *obj) {
-+	duk_tval tv;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+
-+	if (duk_hobject_get_internal_value(heap, obj, &tv)) {
-+		duk_hbuffer *h;
-+		DUK_ASSERT(DUK_TVAL_IS_BUFFER(&tv));
-+		h = DUK_TVAL_GET_BUFFER(&tv);
-+		return h;
-+	}
-+
-+	return NULL;
-+}
-+
-+/*
-+ *  Arguments handling helpers (argument map mainly).
-+ *
-+ *  An arguments object has exotic behavior for some numeric indices.
-+ *  Accesses may translate to identifier operations which may have
-+ *  arbitrary side effects (potentially invalidating any duk_tval
-+ *  pointers).
-+ */
-+
-+/* Lookup 'key' from arguments internal 'map', perform a variable lookup
-+ * if mapped, and leave the result on top of stack (and return non-zero).
-+ * Used in E5 Section 10.6 algorithms [[Get]] and [[GetOwnProperty]].
-+ */
-+DUK_LOCAL
-+duk_bool_t duk__lookup_arguments_map(duk_hthread *thr,
-+                                     duk_hobject *obj,
-+                                     duk_hstring *key,
-+                                     duk_propdesc *temp_desc,
-+                                     duk_hobject **out_map,
-+                                     duk_hobject **out_varenv) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *map;
-+	duk_hobject *varenv;
-+	duk_bool_t rc;
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	DUK_DDD(DUK_DDDPRINT("arguments map lookup: thr=%p, obj=%p, key=%p, temp_desc=%p "
-+	                     "(obj -> %!O, key -> %!O)",
-+	                     (void *) thr, (void *) obj, (void *) key, (void *) temp_desc,
-+	                     (duk_heaphdr *) obj, (duk_heaphdr *) key));
-+
-+	if (!duk__get_own_property_desc(thr, obj, DUK_HTHREAD_STRING_INT_MAP(thr), temp_desc, DUK__DESC_FLAG_PUSH_VALUE)) {
-+		DUK_DDD(DUK_DDDPRINT("-> no 'map'"));
-+		return 0;
-+	}
-+
-+	map = duk_require_hobject(ctx, -1);
-+	DUK_ASSERT(map != NULL);
-+	duk_pop(ctx);  /* map is reachable through obj */
-+
-+	if (!duk__get_own_property_desc(thr, map, key, temp_desc, DUK__DESC_FLAG_PUSH_VALUE)) {
-+		DUK_DDD(DUK_DDDPRINT("-> 'map' exists, but key not in map"));
-+		return 0;
-+	}
-+
-+	/* [... varname] */
-+	DUK_DDD(DUK_DDDPRINT("-> 'map' exists, and contains key, key is mapped to argument/variable binding %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+	DUK_ASSERT(duk_is_string(ctx, -1));  /* guaranteed when building arguments */
-+
-+	/* get varenv for varname (callee's declarative lexical environment) */
-+	rc = duk__get_own_property_desc(thr, obj, DUK_HTHREAD_STRING_INT_VARENV(thr), temp_desc, DUK__DESC_FLAG_PUSH_VALUE);
-+	DUK_UNREF(rc);
-+	DUK_ASSERT(rc != 0);  /* arguments MUST have an initialized lexical environment reference */
-+	varenv = duk_require_hobject(ctx, -1);
-+	DUK_ASSERT(varenv != NULL);
-+	duk_pop(ctx);  /* varenv remains reachable through 'obj' */
-+
-+	DUK_DDD(DUK_DDDPRINT("arguments varenv is: %!dO", (duk_heaphdr *) varenv));
-+
-+	/* success: leave varname in stack */
-+	*out_map = map;
-+	*out_varenv = varenv;
-+	return 1;  /* [... varname] */
-+}
-+
-+/* Lookup 'key' from arguments internal 'map', and leave replacement value
-+ * on stack top if mapped (and return non-zero).
-+ * Used in E5 Section 10.6 algorithm for [[GetOwnProperty]] (used by [[Get]]).
-+ */
-+DUK_LOCAL duk_bool_t duk__check_arguments_map_for_get(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *map;
-+	duk_hobject *varenv;
-+	duk_hstring *varname;
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	if (!duk__lookup_arguments_map(thr, obj, key, temp_desc, &map, &varenv)) {
-+		DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic get behavior"));
-+		return 0;
-+	}
-+
-+	/* [... varname] */
-+
-+	varname = duk_require_hstring(ctx, -1);
-+	DUK_ASSERT(varname != NULL);
-+	duk_pop(ctx);  /* varname is still reachable */
-+
-+	DUK_DDD(DUK_DDDPRINT("arguments object automatic getvar for a bound variable; "
-+	                     "key=%!O, varname=%!O",
-+	                     (duk_heaphdr *) key,
-+	                     (duk_heaphdr *) varname));
-+
-+	(void) duk_js_getvar_envrec(thr, varenv, varname, 1 /*throw*/);
-+
-+	/* [... value this_binding] */
-+
-+	duk_pop(ctx);
-+
-+	/* leave result on stack top */
-+	return 1;
-+}
-+
-+/* Lookup 'key' from arguments internal 'map', perform a variable write if mapped.
-+ * Used in E5 Section 10.6 algorithm for [[DefineOwnProperty]] (used by [[Put]]).
-+ * Assumes stack top contains 'put' value (which is NOT popped).
-+ */
-+DUK_LOCAL void duk__check_arguments_map_for_put(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc, duk_bool_t throw_flag) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *map;
-+	duk_hobject *varenv;
-+	duk_hstring *varname;
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	if (!duk__lookup_arguments_map(thr, obj, key, temp_desc, &map, &varenv)) {
-+		DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic put behavior"));
-+		return;
-+	}
-+
-+	/* [... put_value varname] */
-+
-+	varname = duk_require_hstring(ctx, -1);
-+	DUK_ASSERT(varname != NULL);
-+	duk_pop(ctx);  /* varname is still reachable */
-+
-+	DUK_DDD(DUK_DDDPRINT("arguments object automatic putvar for a bound variable; "
-+	                     "key=%!O, varname=%!O, value=%!T",
-+	                     (duk_heaphdr *) key,
-+	                     (duk_heaphdr *) varname,
-+	                     (duk_tval *) duk_require_tval(ctx, -1)));
-+
-+	/* [... put_value] */
-+
-+	/*
-+	 *  Note: although arguments object variable mappings are only established
-+	 *  for non-strict functions (and a call to a non-strict function created
-+	 *  the arguments object in question), an inner strict function may be doing
-+	 *  the actual property write.  Hence the throw_flag applied here comes from
-+	 *  the property write call.
-+	 */
-+
-+	duk_js_putvar_envrec(thr, varenv, varname, duk_require_tval(ctx, -1), throw_flag);
-+
-+	/* [... put_value] */
-+}
-+
-+/* Lookup 'key' from arguments internal 'map', delete mapping if found.
-+ * Used in E5 Section 10.6 algorithm for [[Delete]].  Note that the
-+ * variable/argument itself (where the map points) is not deleted.
-+ */
-+DUK_LOCAL void duk__check_arguments_map_for_delete(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *temp_desc) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *map;
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	if (!duk__get_own_property_desc(thr, obj, DUK_HTHREAD_STRING_INT_MAP(thr), temp_desc, DUK__DESC_FLAG_PUSH_VALUE)) {
-+		DUK_DDD(DUK_DDDPRINT("arguments: key not mapped, no exotic delete behavior"));
-+		return;
-+	}
-+
-+	map = duk_require_hobject(ctx, -1);
-+	DUK_ASSERT(map != NULL);
-+	duk_pop(ctx);  /* map is reachable through obj */
-+
-+	DUK_DDD(DUK_DDDPRINT("-> have 'map', delete key %!O from map (if exists)); ignore result",
-+	                     (duk_heaphdr *) key));
-+
-+	/* Note: no recursion issue, we can trust 'map' to behave */
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR(map));
-+	DUK_DDD(DUK_DDDPRINT("map before deletion: %!O", (duk_heaphdr *) map));
-+	(void) duk_hobject_delprop_raw(thr, map, key, 0);  /* ignore result */
-+	DUK_DDD(DUK_DDDPRINT("map after deletion: %!O", (duk_heaphdr *) map));
-+}
-+
-+/*
-+ *  Ecmascript compliant [[GetOwnProperty]](P), for internal use only.
-+ *
-+ *  If property is found:
-+ *    - Fills descriptor fields to 'out_desc'
-+ *    - If DUK__DESC_FLAG_PUSH_VALUE is set, pushes a value related to the
-+ *      property onto the stack ('undefined' for accessor properties).
-+ *    - Returns non-zero
-+ *
-+ *  If property is not found:
-+ *    - 'out_desc' is left in untouched state (possibly garbage)
-+ *    - Nothing is pushed onto the stack (not even with DUK__DESC_FLAG_PUSH_VALUE
-+ *      set)
-+ *    - Returns zero
-+ *
-+ *  Notes:
-+ *
-+ *    - Getting a property descriptor may cause an allocation (and hence
-+ *      GC) to take place, hence reachability and refcount of all related
-+ *      values matter.  Reallocation of value stack, properties, etc may
-+ *      invalidate many duk_tval pointers (concretely, those which reside
-+ *      in memory areas subject to reallocation).  However, heap object
-+ *      pointers are never affected (heap objects have stable pointers).
-+ *
-+ *    - The value of a plain property is always reachable and has a non-zero
-+ *      reference count.
-+ *
-+ *    - The value of a virtual property is not necessarily reachable from
-+ *      elsewhere and may have a refcount of zero.  Hence we push it onto
-+ *      the valstack for the caller, which ensures it remains reachable
-+ *      while it is needed.
-+ *
-+ *    - There are no virtual accessor properties.  Hence, all getters and
-+ *      setters are always related to concretely stored properties, which
-+ *      ensures that the get/set functions in the resulting descriptor are
-+ *      reachable and have non-zero refcounts.  Should there be virtual
-+ *      accessor properties later, this would need to change.
-+ */
-+
-+DUK_LOCAL duk_bool_t duk__get_own_property_desc_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_uint32_t arr_idx, duk_propdesc *out_desc, duk_small_uint_t flags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval *tv;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__get_own_property_desc: thr=%p, obj=%p, key=%p, out_desc=%p, flags=%lx, "
-+	                     "arr_idx=%ld (obj -> %!O, key -> %!O)",
-+	                     (void *) thr, (void *) obj, (void *) key, (void *) out_desc,
-+	                     (long) flags, (long) arr_idx,
-+	                     (duk_heaphdr *) obj, (duk_heaphdr *) key));
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(out_desc != NULL);
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/* XXX: optimize this filling behavior later */
-+	out_desc->flags = 0;
-+	out_desc->get = NULL;
-+	out_desc->set = NULL;
-+	out_desc->e_idx = -1;
-+	out_desc->h_idx = -1;
-+	out_desc->a_idx = -1;
-+
-+	/*
-+	 *  Array part
-+	 */
-+
-+	if (DUK_HOBJECT_HAS_ARRAY_PART(obj) && arr_idx != DUK__NO_ARRAY_INDEX) {
-+		if (arr_idx < DUK_HOBJECT_GET_ASIZE(obj)) {
-+			tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
-+			if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
-+				DUK_DDD(DUK_DDDPRINT("-> found in array part"));
-+				if (flags & DUK__DESC_FLAG_PUSH_VALUE) {
-+					duk_push_tval(ctx, tv);
-+				}
-+				/* implicit attributes */
-+				out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE |
-+				                  DUK_PROPDESC_FLAG_CONFIGURABLE |
-+				                  DUK_PROPDESC_FLAG_ENUMERABLE;
-+				out_desc->a_idx = arr_idx;
-+				goto prop_found;
-+			}
-+		}
-+		/* assume array part is comprehensive (contains all array indexed elements
-+		 * or none of them); hence no need to check the entries part here.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("-> not found as a concrete property (has array part, "
-+		                     "should be there if present)"));
-+		goto prop_not_found_concrete;
-+	}
-+
-+	/*
-+	 *  Entries part
-+	 */
-+
-+	duk_hobject_find_existing_entry(thr->heap, obj, key, &out_desc->e_idx, &out_desc->h_idx);
-+	if (out_desc->e_idx >= 0) {
-+		duk_int_t e_idx = out_desc->e_idx;
-+		out_desc->flags = DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, e_idx);
-+		if (out_desc->flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+			DUK_DDD(DUK_DDDPRINT("-> found accessor property in entry part"));
-+			out_desc->get = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, e_idx);
-+			out_desc->set = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, e_idx);
-+			if (flags & DUK__DESC_FLAG_PUSH_VALUE) {
-+				/* a dummy undefined value is pushed to make valstack
-+				 * behavior uniform for caller
-+				 */
-+				duk_push_undefined(ctx);
-+			}
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("-> found plain property in entry part"));
-+			tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
-+			if (flags & DUK__DESC_FLAG_PUSH_VALUE) {
-+				duk_push_tval(ctx, tv);
-+			}
-+		}
-+		goto prop_found;
-+	}
-+
-+	/*
-+	 *  Not found as a concrete property, check whether a String object
-+	 *  virtual property matches.
-+	 */
-+
-+ prop_not_found_concrete:
-+
-+	if (DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj)) {
-+		DUK_DDD(DUK_DDDPRINT("string object exotic property get for key: %!O, arr_idx: %ld",
-+		                     (duk_heaphdr *) key, (long) arr_idx));
-+
-+		if (arr_idx != DUK__NO_ARRAY_INDEX) {
-+			duk_hstring *h_val;
-+
-+			DUK_DDD(DUK_DDDPRINT("array index exists"));
-+
-+			h_val = duk_hobject_get_internal_value_string(thr->heap, obj);
-+			DUK_ASSERT(h_val);
-+			if (arr_idx < DUK_HSTRING_GET_CHARLEN(h_val)) {
-+				DUK_DDD(DUK_DDDPRINT("-> found, array index inside string"));
-+				if (flags & DUK__DESC_FLAG_PUSH_VALUE) {
-+					duk_push_hstring(ctx, h_val);
-+					duk_substring(ctx, -1, arr_idx, arr_idx + 1);  /* [str] -> [substr] */
-+				}
-+				out_desc->flags = DUK_PROPDESC_FLAG_ENUMERABLE |  /* E5 Section 15.5.5.2 */
-+				                  DUK_PROPDESC_FLAG_VIRTUAL;
-+
-+				DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
-+				return 1;  /* cannot be e.g. arguments exotic, since exotic 'traits' are mutually exclusive */
-+			} else {
-+				/* index is above internal string length -> property is fully normal */
-+				DUK_DDD(DUK_DDDPRINT("array index outside string -> normal property"));
-+			}
-+		} else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			duk_hstring *h_val;
-+
-+			DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
-+
-+			h_val = duk_hobject_get_internal_value_string(thr->heap, obj);
-+			DUK_ASSERT(h_val != NULL);
-+			if (flags & DUK__DESC_FLAG_PUSH_VALUE) {
-+				duk_push_uint(ctx, (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h_val));
-+			}
-+			out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;  /* E5 Section 15.5.5.1 */
-+
-+			DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
-+			return 1;  /* cannot be arguments exotic */
-+		}
-+	} else if (DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(obj)) {
-+		DUK_DDD(DUK_DDDPRINT("buffer object exotic property get for key: %!O, arr_idx: %ld",
-+		                     (duk_heaphdr *) key, (long) arr_idx));
-+
-+		if (arr_idx != DUK__NO_ARRAY_INDEX) {
-+			duk_hbuffer *h_val;
-+
-+			DUK_DDD(DUK_DDDPRINT("array index exists"));
-+
-+			h_val = duk_hobject_get_internal_value_buffer(thr->heap, obj);
-+			DUK_ASSERT(h_val);
-+			/* SCANBUILD: h_val is known to be non-NULL but scan-build cannot
-+			 * know it, so it produces NULL pointer dereference warnings for
-+			 * 'h_val'.
-+			 */
-+
-+			if (arr_idx < DUK_HBUFFER_GET_SIZE(h_val)) {
-+				DUK_DDD(DUK_DDDPRINT("-> found, array index inside buffer"));
-+				if (flags & DUK__DESC_FLAG_PUSH_VALUE) {
-+					duk_push_int(ctx, ((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_val))[arr_idx]);
-+				}
-+				out_desc->flags = DUK_PROPDESC_FLAG_WRITABLE |
-+				                  DUK_PROPDESC_FLAG_ENUMERABLE |
-+				                  DUK_PROPDESC_FLAG_VIRTUAL;
-+
-+				DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
-+				return 1;  /* cannot be e.g. arguments exotic, since exotic 'traits' are mutually exclusive */
-+			} else {
-+				/* index is above internal buffer length -> property is fully normal */
-+				DUK_DDD(DUK_DDDPRINT("array index outside buffer -> normal property"));
-+			}
-+		} else if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			duk_hbuffer *h_val;
-+
-+			DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
-+
-+			/* XXX: buffer length should be writable and have exotic behavior
-+			 * like arrays.  For now, make it read-only and use explicit methods
-+			 * to operate on buffer length.
-+			 */
-+
-+			h_val = duk_hobject_get_internal_value_buffer(thr->heap, obj);
-+			DUK_ASSERT(h_val != NULL);
-+			if (flags & DUK__DESC_FLAG_PUSH_VALUE) {
-+				duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h_val));
-+			}
-+			out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;
-+
-+			DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
-+			return 1;  /* cannot be arguments exotic */
-+		}
-+	} else if (DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(obj)) {
-+		DUK_DDD(DUK_DDDPRINT("duktape/c object exotic property get for key: %!O, arr_idx: %ld",
-+		                     (duk_heaphdr *) key, (long) arr_idx));
-+
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			DUK_DDD(DUK_DDDPRINT("-> found, key is 'length', length exotic behavior"));
-+
-+			if (flags & DUK__DESC_FLAG_PUSH_VALUE) {
-+				duk_int16_t func_nargs = ((duk_hnativefunction *) obj)->nargs;
-+				duk_push_int(ctx, func_nargs == DUK_HNATIVEFUNCTION_NARGS_VARARGS ? 0 : func_nargs);
-+			}
-+			out_desc->flags = DUK_PROPDESC_FLAG_VIRTUAL;  /* not enumerable */
-+
-+			DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj));
-+			return 1;  /* cannot be arguments exotic */
-+		}
-+	}
-+
-+	/* Array properties have exotic behavior but they are concrete,
-+	 * so no special handling here.
-+	 *
-+	 * Arguments exotic behavior (E5 Section 10.6, [[GetOwnProperty]]
-+	 * is only relevant as a post-check implemented below; hence no
-+	 * check here.
-+	 */
-+
-+	/*
-+	 *  Not found as concrete or virtual
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("-> not found (virtual, entry part, or array part)"));
-+	return 0;
-+
-+	/*
-+	 *  Found
-+	 *
-+	 *  Arguments object has exotic post-processing, see E5 Section 10.6,
-+	 *  description of [[GetOwnProperty]] variant for arguments.
-+	 */
-+
-+ prop_found:
-+	DUK_DDD(DUK_DDDPRINT("-> property found, checking for arguments exotic post-behavior"));
-+
-+	/* Notes:
-+	 *  - only numbered indices are relevant, so arr_idx fast reject is good
-+	 *    (this is valid unless there are more than 4**32-1 arguments).
-+	 *  - since variable lookup has no side effects, this can be skipped if
-+	 *    DUK__DESC_FLAG_PUSH_VALUE is not set.
-+	 */
-+
-+	if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) &&
-+	    arr_idx != DUK__NO_ARRAY_INDEX &&
-+	    (flags & DUK__DESC_FLAG_PUSH_VALUE)) {
-+		duk_propdesc temp_desc;
-+
-+		/* Magically bound variable cannot be an accessor.  However,
-+		 * there may be an accessor property (or a plain property) in
-+		 * place with magic behavior removed.  This happens e.g. when
-+		 * a magic property is redefined with defineProperty().
-+		 * Cannot assert for "not accessor" here.
-+		 */
-+
-+		/* replaces top of stack with new value if necessary */
-+		DUK_ASSERT((flags & DUK__DESC_FLAG_PUSH_VALUE) != 0);
-+
-+		if (duk__check_arguments_map_for_get(thr, obj, key, &temp_desc)) {
-+			DUK_DDD(DUK_DDDPRINT("-> arguments exotic behavior overrides result: %!T -> %!T",
-+			                     (duk_tval *) duk_get_tval(ctx, -2),
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			/* [... old_result result] -> [... result] */
-+			duk_remove(ctx, -2);
-+		}
-+	}
-+
-+	return 1;
-+}
-+
-+DUK_LOCAL duk_bool_t duk__get_own_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags) {
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(out_desc != NULL);
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	return duk__get_own_property_desc_raw(thr, obj, key, DUK_HSTRING_GET_ARRIDX_SLOW(key), out_desc, flags);
-+}
-+
-+/*
-+ *  Ecmascript compliant [[GetProperty]](P), for internal use only.
-+ *
-+ *  If property is found:
-+ *    - Fills descriptor fields to 'out_desc'
-+ *    - If DUK__DESC_FLAG_PUSH_VALUE is set, pushes a value related to the
-+ *      property onto the stack ('undefined' for accessor properties).
-+ *    - Returns non-zero
-+ *
-+ *  If property is not found:
-+ *    - 'out_desc' is left in untouched state (possibly garbage)
-+ *    - Nothing is pushed onto the stack (not even with DUK__DESC_FLAG_PUSH_VALUE
-+ *      set)
-+ *    - Returns zero
-+ *
-+ *  May cause arbitrary side effects and invalidate (most) duk_tval
-+ *  pointers.
-+ */
-+
-+DUK_LOCAL duk_bool_t duk__get_property_desc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags) {
-+	duk_hobject *curr;
-+	duk_uint32_t arr_idx;
-+	duk_uint_t sanity;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(out_desc != NULL);
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__get_property_desc: thr=%p, obj=%p, key=%p, out_desc=%p, flags=%lx, "
-+	                     "arr_idx=%ld (obj -> %!O, key -> %!O)",
-+	                     (void *) thr, (void *) obj, (void *) key, (void *) out_desc,
-+	                     (long) flags, (long) arr_idx,
-+	                     (duk_heaphdr *) obj, (duk_heaphdr *) key));
-+
-+	curr = obj;
-+	DUK_ASSERT(curr != NULL);
-+	sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
-+	do {
-+		if (duk__get_own_property_desc_raw(thr, curr, key, arr_idx, out_desc, flags)) {
-+			/* stack contains value (if requested), 'out_desc' is set */
-+			return 1;
-+		}
-+
-+		/* not found in 'curr', next in prototype chain; impose max depth */
-+		if (sanity-- == 0) {
-+			if (flags & DUK__DESC_FLAG_IGNORE_PROTOLOOP) {
-+				/* treat like property not found */
-+				break;
-+			} else {
-+				DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
-+			}
-+		}
-+		curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
-+	} while (curr);
-+
-+	/* out_desc is left untouched (possibly garbage), caller must use return
-+	 * value to determine whether out_desc can be looked up
-+	 */
-+
-+	return 0;
-+}
-+
-+/*
-+ *  Shallow fast path checks for accessing array elements with numeric
-+ *  indices.  The goal is to try to avoid coercing an array index to an
-+ *  (interned) string for the most common lookups, in particular, for
-+ *  standard Array objects.
-+ *
-+ *  Interning is avoided but only for a very narrow set of cases:
-+ *    - Object has array part, index is within array allocation, and
-+ *      value is not unused (= key exists)
-+ *    - Object has no interfering exotic behavior (e.g. arguments or
-+ *      string object exotic behaviors interfere, array exotic
-+ *      behavior does not).
-+ *
-+ *  Current shortcoming: if key does not exist (even if it is within
-+ *  the array allocation range) a slow path lookup with interning is
-+ *  always required.  This can probably be fixed so that there is a
-+ *  quick fast path for non-existent elements as well, at least for
-+ *  standard Array objects.
-+ */
-+
-+#if 0  /* XXX: unused now */
-+DUK_LOCAL duk_tval *duk__shallow_fast_path_array_check_u32(duk_hobject *obj, duk_uint32_t key_idx) {
-+	duk_tval *tv;
-+
-+	if ((!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) &&
-+	    (!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj)) &&
-+	    (!DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(obj)) &&
-+	    (!DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj)) &&
-+	    (DUK_HOBJECT_HAS_ARRAY_PART(obj)) &&
-+	    (key_idx < obj->a_size)) {
-+		/* technically required to check, but obj->a_size check covers this */
-+		DUK_ASSERT(key_idx != 0xffffffffUL);
-+
-+		DUK_DDD(DUK_DDDPRINT("fast path attempt (key is an array index, no exotic "
-+		                     "string/arguments/buffer behavior, object has array part, key "
-+		                     "inside array size)"));
-+
-+		DUK_ASSERT(obj->a_size > 0);  /* true even for key_idx == 0 */
-+		tv = DUK_HOBJECT_A_GET_VALUE_PTR(obj, key_idx);
-+		if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
-+			DUK_DDD(DUK_DDDPRINT("-> fast path successful"));
-+			return tv;
-+		}
-+
-+		/*
-+		 *  Not found, fall back to slow path.
-+		 *
-+		 *  Note: this approach has the unfortunate side effect that accesses
-+		 *  to undefined entries (or entries outside valid array range) cause
-+		 *  a string intern operation.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("fast path attempt failed, fall back to slow path"));
-+	}
-+
-+	return NULL;
-+}
-+#endif
-+
-+DUK_LOCAL duk_tval *duk__shallow_fast_path_array_check_tval(duk_hthread *thr, duk_hobject *obj, duk_tval *key_tv) {
-+	duk_tval *tv;
-+	duk_uint32_t idx;
-+
-+	DUK_UNREF(thr);
-+
-+	if (!(DUK_HOBJECT_HAS_ARRAY_PART(obj) &&
-+	     !DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj) &&
-+	     !DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(obj) &&
-+	     !DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(obj) &&
-+	     !DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) {
-+		/* Must have array part and no conflicting exotic behaviors.
-+		 * Doesn't need to have array special behavior, e.g. Arguments
-+		 * object has array part.
-+		 */
-+		return NULL;
-+	}
-+
-+	/* Arrays never have other exotic behaviors. */
-+
-+	DUK_DDD(DUK_DDDPRINT("fast path attempt (no exotic string/arguments/buffer "
-+	                     "behavior, object has array part)"));
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(key_tv)) {
-+		idx = duk__tval_fastint_to_arr_idx(key_tv);
-+	} else
-+#endif
-+	if (DUK_TVAL_IS_NUMBER(key_tv)) {
-+		idx = duk__tval_number_to_arr_idx(key_tv);
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("key is not a number"));
-+		return NULL;
-+	}
-+
-+	if (idx != DUK__NO_ARRAY_INDEX) {
-+		/* Note: idx is not necessarily a valid array index (0xffffffffUL is not valid) */
-+		DUK_ASSERT_DISABLE(idx >= 0);  /* disabled because idx is duk_uint32_t so always true */
-+		DUK_ASSERT_DISABLE(idx <= 0xffffffffUL);  /* same */
-+
-+		if (idx < DUK_HOBJECT_GET_ASIZE(obj)) {
-+			/* technically required to check, but obj->a_size check covers this */
-+			DUK_ASSERT(idx != 0xffffffffUL);
-+
-+			/* XXX: for array instances we could take a shortcut here and assume
-+			 * Array.prototype doesn't contain an array index property.
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("key is a valid array index and inside array part"));
-+			tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, idx);
-+			if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
-+				DUK_DDD(DUK_DDDPRINT("-> fast path successful"));
-+				return tv;
-+			}
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("key is outside array part"));
-+		}
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("key is not a valid array index"));
-+	}
-+
-+	/*
-+	 *  Not found in array part, use slow path.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("fast path attempt failed, fall back to slow path"));
-+	return NULL;
-+}
-+
-+/*
-+ *  GETPROP: Ecmascript property read.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_getprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval tv_obj_copy;
-+	duk_tval tv_key_copy;
-+	duk_hobject *curr = NULL;
-+	duk_hstring *key = NULL;
-+	duk_uint32_t arr_idx = DUK__NO_ARRAY_INDEX;
-+	duk_propdesc desc;
-+	duk_uint_t sanity;
-+
-+	DUK_DDD(DUK_DDDPRINT("getprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
-+	                     (void *) thr, (void *) tv_obj, (void *) tv_key,
-+	                     (duk_tval *) tv_obj, (duk_tval *) tv_key));
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(tv_obj != NULL);
-+	DUK_ASSERT(tv_key != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/*
-+	 *  Make a copy of tv_obj, tv_key, and tv_val to avoid any issues of
-+	 *  them being invalidated by a valstack resize.
-+	 *
-+	 *  XXX: this is now an overkill for many fast paths.  Rework this
-+	 *  to be faster (although switching to a valstack discipline might
-+	 *  be a better solution overall).
-+	 */
-+
-+	DUK_TVAL_SET_TVAL(&tv_obj_copy, tv_obj);
-+	DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
-+	tv_obj = &tv_obj_copy;
-+	tv_key = &tv_key_copy;
-+
-+	/*
-+	 *  Coercion and fast path processing
-+	 */
-+
-+	switch (DUK_TVAL_GET_TAG(tv_obj)) {
-+	case DUK_TAG_UNDEFINED:
-+	case DUK_TAG_NULL: {
-+		/* Note: unconditional throw */
-+		DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject"));
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE);
-+		return 0;
-+	}
-+
-+	case DUK_TAG_BOOLEAN: {
-+		DUK_DDD(DUK_DDDPRINT("base object is a boolean, start lookup from boolean prototype"));
-+		curr = thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE];
-+		break;
-+	}
-+
-+	case DUK_TAG_STRING: {
-+		duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
-+		duk_int_t pop_count;
-+
-+#if defined(DUK_USE_FASTINT)
-+		if (DUK_TVAL_IS_FASTINT(tv_key)) {
-+			arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
-+			DUK_DDD(DUK_DDDPRINT("base object string, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
-+			pop_count = 0;
-+		} else
-+#endif
-+		if (DUK_TVAL_IS_NUMBER(tv_key)) {
-+			arr_idx = duk__tval_number_to_arr_idx(tv_key);
-+			DUK_DDD(DUK_DDDPRINT("base object string, key is a fast-path number; arr_idx %ld", (long) arr_idx));
-+			pop_count = 0;
-+		} else {
-+			arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+			DUK_ASSERT(key != NULL);
-+			DUK_DDD(DUK_DDDPRINT("base object string, key is a non-fast-path number; after "
-+			                     "coercion key is %!T, arr_idx %ld",
-+			                     (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
-+			pop_count = 1;
-+		}
-+
-+		if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+		    arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
-+			duk_pop_n(ctx, pop_count);
-+			duk_push_hstring(ctx, h);
-+			duk_substring(ctx, -1, arr_idx, arr_idx + 1);  /* [str] -> [substr] */
-+
-+			DUK_DDD(DUK_DDDPRINT("-> %!T (base is string, key is an index inside string length "
-+			                     "after coercion -> return char)",
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			return 1;
-+		}
-+
-+		if (pop_count == 0) {
-+			/* This is a pretty awkward control flow, but we need to recheck the
-+			 * key coercion here.
-+			 */
-+			arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+			DUK_ASSERT(key != NULL);
-+			DUK_DDD(DUK_DDDPRINT("base object string, key is a non-fast-path number; after "
-+			                     "coercion key is %!T, arr_idx %ld",
-+			                     (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
-+		}
-+
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			duk_pop(ctx);  /* [key] -> [] */
-+			duk_push_uint(ctx, (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h));  /* [] -> [res] */
-+
-+			DUK_DDD(DUK_DDDPRINT("-> %!T (base is string, key is 'length' after coercion -> "
-+			                     "return string length)",
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			return 1;
-+		}
-+		DUK_DDD(DUK_DDDPRINT("base object is a string, start lookup from string prototype"));
-+		curr = thr->builtins[DUK_BIDX_STRING_PROTOTYPE];
-+		goto lookup;  /* avoid double coercion */
-+	}
-+
-+	case DUK_TAG_OBJECT: {
-+		duk_tval *tmp;
-+
-+		curr = DUK_TVAL_GET_OBJECT(tv_obj);
-+		DUK_ASSERT(curr != NULL);
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+		if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(curr))) {
-+			duk_hobject *h_target;
-+
-+			if (duk__proxy_check_prop(thr, curr, DUK_STRIDX_GET, tv_key, &h_target)) {
-+				/* -> [ ... trap handler ] */
-+				DUK_DDD(DUK_DDDPRINT("-> proxy object 'get' for key %!T", (duk_tval *) tv_key));
-+				duk_push_hobject(ctx, h_target);  /* target */
-+				duk_push_tval(ctx, tv_key);       /* P */
-+				duk_push_tval(ctx, tv_obj);       /* Receiver: Proxy object */
-+				duk_call_method(ctx, 3 /*nargs*/);
-+
-+				/* Target object must be checked for a conflicting
-+				 * non-configurable property.
-+				 */
-+				arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+				DUK_ASSERT(key != NULL);
-+
-+				if (duk__get_own_property_desc_raw(thr, h_target, key, arr_idx, &desc, DUK__DESC_FLAG_PUSH_VALUE)) {
-+					duk_tval *tv_hook = duk_require_tval(ctx, -3);  /* value from hook */
-+					duk_tval *tv_targ = duk_require_tval(ctx, -1);  /* value from target */
-+					duk_bool_t datadesc_reject;
-+					duk_bool_t accdesc_reject;
-+
-+					DUK_DDD(DUK_DDDPRINT("proxy 'get': target has matching property %!O, check for "
-+					                     "conflicting property; tv_hook=%!T, tv_targ=%!T, desc.flags=0x%08lx, "
-+					                     "desc.get=%p, desc.set=%p",
-+					                     (duk_heaphdr *) key, (duk_tval *) tv_hook, (duk_tval *) tv_targ,
-+					                     (unsigned long) desc.flags,
-+					                     (void *) desc.get, (void *) desc.set));
-+
-+					datadesc_reject = !(desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
-+					                  !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&
-+					                  !(desc.flags & DUK_PROPDESC_FLAG_WRITABLE) &&
-+					                  !duk_js_samevalue(tv_hook, tv_targ);
-+					accdesc_reject = (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
-+					                 !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&
-+					                 (desc.get == NULL) &&
-+					                 !DUK_TVAL_IS_UNDEFINED(tv_hook);
-+					if (datadesc_reject || accdesc_reject) {
-+						DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED);
-+					}
-+
-+					duk_pop_2(ctx);
-+				} else {
-+					duk_pop(ctx);
-+				}
-+				return 1;  /* return value */
-+			}
-+
-+			curr = h_target;  /* resume lookup from target */
-+			DUK_TVAL_SET_OBJECT(tv_obj, curr);
-+		}
-+#endif  /* DUK_USE_ES6_PROXY */
-+
-+		tmp = duk__shallow_fast_path_array_check_tval(thr, curr, tv_key);
-+		if (tmp) {
-+			duk_push_tval(ctx, tmp);
-+
-+			DUK_DDD(DUK_DDDPRINT("-> %!T (base is object, key is a number, array part "
-+			                     "fast path)",
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			return 1;
-+		}
-+
-+		if (DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(curr)) {
-+			arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+			DUK_ASSERT(key != NULL);
-+
-+			if (duk__check_arguments_map_for_get(thr, curr, key, &desc)) {
-+				DUK_DDD(DUK_DDDPRINT("-> %!T (base is object with arguments exotic behavior, "
-+				                     "key matches magically bound property -> skip standard "
-+				                     "Get with replacement value)",
-+				                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+				/* no need for 'caller' post-check, because 'key' must be an array index */
-+
-+				duk_remove(ctx, -2);  /* [key result] -> [result] */
-+				return 1;
-+			}
-+
-+			goto lookup;  /* avoid double coercion */
-+		}
-+		break;
-+	}
-+
-+	/* Buffer has virtual properties similar to string, but indexed values
-+	 * are numbers, not 1-byte buffers/strings which would perform badly.
-+	 */
-+	case DUK_TAG_BUFFER: {
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
-+		duk_int_t pop_count;
-+
-+		/*
-+		 *  Because buffer values are often looped over, a number fast path
-+		 *  is important.
-+		 */
-+
-+#if defined(DUK_USE_FASTINT)
-+		if (DUK_TVAL_IS_FASTINT(tv_key)) {
-+			arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
-+			DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
-+			pop_count = 0;
-+		}
-+		else
-+#endif
-+		if (DUK_TVAL_IS_NUMBER(tv_key)) {
-+			arr_idx = duk__tval_number_to_arr_idx(tv_key);
-+			DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path number; arr_idx %ld", (long) arr_idx));
-+			pop_count = 0;
-+		} else {
-+			arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+			DUK_ASSERT(key != NULL);
-+			DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
-+			                     "coercion key is %!T, arr_idx %ld",
-+			                     (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
-+			pop_count = 1;
-+		}
-+
-+		if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+		    arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
-+			duk_pop_n(ctx, pop_count);
-+			duk_push_int(ctx, ((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h))[arr_idx]);
-+
-+			DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is an index inside buffer length "
-+			                     "after coercion -> return byte as number)",
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			return 1;
-+		}
-+
-+		if (pop_count == 0) {
-+			/* This is a pretty awkward control flow, but we need to recheck the
-+			 * key coercion here.
-+			 */
-+			arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+			DUK_ASSERT(key != NULL);
-+			DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
-+			                     "coercion key is %!T, arr_idx %ld",
-+			                     (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
-+		}
-+
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			duk_pop(ctx);  /* [key] -> [] */
-+			duk_push_uint(ctx, (duk_uint_t) DUK_HBUFFER_GET_SIZE(h));  /* [] -> [res] */
-+
-+			DUK_DDD(DUK_DDDPRINT("-> %!T (base is buffer, key is 'length' after coercion -> "
-+			                     "return buffer length)",
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			return 1;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("base object is a buffer, start lookup from buffer prototype"));
-+		curr = thr->builtins[DUK_BIDX_BUFFER_PROTOTYPE];
-+		goto lookup;  /* avoid double coercion */
-+	}
-+
-+	case DUK_TAG_POINTER: {
-+		DUK_DDD(DUK_DDDPRINT("base object is a pointer, start lookup from pointer prototype"));
-+		curr = thr->builtins[DUK_BIDX_POINTER_PROTOTYPE];
-+		break;
-+	}
-+
-+	case DUK_TAG_LIGHTFUNC: {
-+		duk_int_t lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_obj);
-+
-+		/* Must coerce key: if key is an object, it may coerce to e.g. 'length'. */
-+		arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			duk_int_t lf_len = DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags);
-+			duk_pop(ctx);
-+			duk_push_int(ctx, lf_len);
-+			return 1;
-+		} else if (key == DUK_HTHREAD_STRING_NAME(thr)) {
-+			duk_pop(ctx);
-+			duk_push_lightfunc_name(ctx, tv_obj);
-+			return 1;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("base object is a lightfunc, start lookup from function prototype"));
-+		curr = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
-+		goto lookup;  /* avoid double coercion */
-+	}
-+
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default: {
-+		/* number */
-+		DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype"));
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_obj));
-+		curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE];
-+		break;
-+	}
-+	}
-+
-+	/* key coercion (unless already coerced above) */
-+	DUK_ASSERT(key == NULL);
-+	arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+	DUK_ASSERT(key != NULL);
-+
-+	/*
-+	 *  Property lookup
-+	 */
-+
-+ lookup:
-+	/* [key] (coerced) */
-+	DUK_ASSERT(curr != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
-+	do {
-+		if (!duk__get_own_property_desc_raw(thr, curr, key, arr_idx, &desc, DUK__DESC_FLAG_PUSH_VALUE)) {
-+			goto next_in_chain;
-+		}
-+
-+		if (desc.get != NULL) {
-+			/* accessor with defined getter */
-+			DUK_ASSERT((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0);
-+
-+			duk_pop(ctx);                     /* [key undefined] -> [key] */
-+			duk_push_hobject(ctx, desc.get);
-+			duk_push_tval(ctx, tv_obj);       /* note: original, uncoerced base */
-+#ifdef DUK_USE_NONSTD_GETTER_KEY_ARGUMENT
-+			duk_dup(ctx, -3);
-+			duk_call_method(ctx, 1);          /* [key getter this key] -> [key retval] */
-+#else
-+			duk_call_method(ctx, 0);          /* [key getter this] -> [key retval] */
-+#endif
-+		} else {
-+			/* [key value] or [key undefined] */
-+
-+			/* data property or accessor without getter */
-+			DUK_ASSERT(((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0) ||
-+			           (desc.get == NULL));
-+
-+			/* if accessor without getter, return value is undefined */
-+			DUK_ASSERT(((desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0) ||
-+			           duk_is_undefined(ctx, -1));
-+
-+			/* Note: for an accessor without getter, falling through to
-+			 * check for "caller" exotic behavior is unnecessary as
-+			 * "undefined" will never activate the behavior.  But it does
-+			 * no harm, so we'll do it anyway.
-+			 */
-+		}
-+
-+		goto found;  /* [key result] */
-+
-+	 next_in_chain:
-+		/* XXX: option to pretend property doesn't exist if sanity limit is
-+		 * hit might be useful.
-+		 */
-+		if (sanity-- == 0) {
-+			DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
-+		}
-+		curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
-+	} while (curr);
-+
-+	/*
-+	 *  Not found
-+	 */
-+
-+	duk_to_undefined(ctx, -1);  /* [key] -> [undefined] (default value) */
-+
-+	DUK_DDD(DUK_DDDPRINT("-> %!T (not found)", (duk_tval *) duk_get_tval(ctx, -1)));
-+	return 0;
-+
-+	/*
-+	 *  Found; post-processing (Function and arguments objects)
-+	 */
-+
-+ found:
-+	/* [key result] */
-+
-+#if !defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
-+	/* Special behavior for 'caller' property of (non-bound) function objects
-+	 * and non-strict Arguments objects: if 'caller' -value- (!) is a strict
-+	 * mode function, throw a TypeError (E5 Sections 15.3.5.4, 10.6).
-+	 * Quite interestingly, a non-strict function with no formal arguments
-+	 * will get an arguments object -without- special 'caller' behavior!
-+	 *
-+	 * The E5.1 spec is a bit ambiguous if this special behavior applies when
-+	 * a bound function is the base value (not the 'caller' value): Section
-+	 * 15.3.4.5 (describing bind()) states that [[Get]] for bound functions
-+	 * matches that of Section 15.3.5.4 ([[Get]] for Function instances).
-+	 * However, Section 13.3.5.4 has "NOTE: Function objects created using
-+	 * Function.prototype.bind use the default [[Get]] internal method."
-+	 * The current implementation assumes this means that bound functions
-+	 * should not have the special [[Get]] behavior.
-+	 *
-+	 * The E5.1 spec is also a bit unclear if the TypeError throwing is
-+	 * applied if the 'caller' value is a strict bound function.  The
-+	 * current implementation will throw even for both strict non-bound
-+	 * and strict bound functions.
-+	 *
-+	 * See test-dev-strict-func-as-caller-prop-value.js for quite extensive
-+	 * tests.
-+	 *
-+	 * This exotic behavior is disabled when the non-standard 'caller' property
-+	 * is enabled, as it conflicts with the free use of 'caller'.
-+	 */
-+	if (key == DUK_HTHREAD_STRING_CALLER(thr) &&
-+	    DUK_TVAL_IS_OBJECT(tv_obj)) {
-+		duk_hobject *orig = DUK_TVAL_GET_OBJECT(tv_obj);
-+		DUK_ASSERT(orig != NULL);
-+
-+		if (DUK_HOBJECT_IS_NONBOUND_FUNCTION(orig) ||
-+		    DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(orig)) {
-+			duk_hobject *h;
-+
-+			/* XXX: The TypeError is currently not applied to bound
-+			 * functions because the 'strict' flag is not copied by
-+			 * bind().  This may or may not be correct, the specification
-+			 * only refers to the value being a "strict mode Function
-+			 * object" which is ambiguous.
-+			 */
-+			DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(orig));
-+
-+			h = duk_get_hobject(ctx, -1);  /* NULL if not an object */
-+			if (h &&
-+			    DUK_HOBJECT_IS_FUNCTION(h) &&
-+			    DUK_HOBJECT_HAS_STRICT(h)) {
-+				/* XXX: sufficient to check 'strict', assert for 'is function' */
-+				DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_STRICT_CALLER_READ);
-+			}
-+		}
-+	}
-+#endif   /* !DUK_USE_NONSTD_FUNC_CALLER_PROPERTY */
-+
-+	duk_remove(ctx, -2);  /* [key result] -> [result] */
-+
-+	DUK_DDD(DUK_DDDPRINT("-> %!T (found)", (duk_tval *) duk_get_tval(ctx, -1)));
-+	return 1;
-+}
-+
-+/*
-+ *  HASPROP: Ecmascript property existence check ("in" operator).
-+ *
-+ *  Interestingly, the 'in' operator does not do any coercion of
-+ *  the target object.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_hasprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval tv_key_copy;
-+	duk_hobject *obj;
-+	duk_hstring *key;
-+	duk_uint32_t arr_idx;
-+	duk_bool_t rc;
-+	duk_propdesc desc;
-+
-+	DUK_DDD(DUK_DDDPRINT("hasprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
-+	                     (void *) thr, (void *) tv_obj, (void *) tv_key,
-+	                     (duk_tval *) tv_obj, (duk_tval *) tv_key));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(tv_obj != NULL);
-+	DUK_ASSERT(tv_key != NULL);
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
-+	tv_key = &tv_key_copy;
-+
-+	/*
-+	 *  The 'in' operator requires an object as its right hand side,
-+	 *  throwing a TypeError unconditionally if this is not the case.
-+	 *
-+	 *  However, lightfuncs need to behave like fully fledged objects
-+	 *  here to be maximally transparent, so we need to handle them
-+	 *  here.
-+	 */
-+
-+	/* XXX: Refactor key coercion so that it's only called once.  It can't
-+	 * be trivially lifted here because the object must be type checked
-+	 * first.
-+	 */
-+
-+	if (DUK_TVAL_IS_OBJECT(tv_obj)) {
-+		obj = DUK_TVAL_GET_OBJECT(tv_obj);
-+		DUK_ASSERT(obj != NULL);
-+
-+		arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+	} else if (DUK_TVAL_IS_LIGHTFUNC(tv_obj)) {
-+		arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+		if (duk__key_is_lightfunc_ownprop(thr, key)) {
-+			/* FOUND */
-+			rc = 1;
-+			goto pop_and_return;
-+		}
-+
-+		/* If not found, resume existence check from Function.prototype.
-+		 * We can just substitute the value in this case; nothing will
-+		 * need the original base value (as would be the case with e.g.
-+		 * setters/getters.
-+		 */
-+		obj = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
-+	} else {
-+		/* Note: unconditional throw */
-+		DUK_DDD(DUK_DDDPRINT("base object is not an object -> reject"));
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE);
-+	}
-+
-+	/* XXX: fast path for arrays? */
-+
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_UNREF(arr_idx);
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+	if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) {
-+		duk_hobject *h_target;
-+		duk_bool_t tmp_bool;
-+
-+		/* XXX: the key in 'key in obj' is string coerced before we're called
-+		 * (which is the required behavior in E5/E5.1/E6) so the key is a string
-+		 * here already.
-+		 */
-+
-+		if (duk__proxy_check_prop(thr, obj, DUK_STRIDX_HAS, tv_key, &h_target)) {
-+			/* [ ... key trap handler ] */
-+			DUK_DDD(DUK_DDDPRINT("-> proxy object 'has' for key %!T", (duk_tval *) tv_key));
-+			duk_push_hobject(ctx, h_target);  /* target */
-+			duk_push_tval(ctx, tv_key);       /* P */
-+			duk_call_method(ctx, 2 /*nargs*/);
-+			tmp_bool = duk_to_boolean(ctx, -1);
-+			if (!tmp_bool) {
-+				/* Target object must be checked for a conflicting
-+				 * non-configurable property.
-+				 */
-+
-+				if (duk__get_own_property_desc_raw(thr, h_target, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
-+					DUK_DDD(DUK_DDDPRINT("proxy 'has': target has matching property %!O, check for "
-+					                     "conflicting property; desc.flags=0x%08lx, "
-+					                     "desc.get=%p, desc.set=%p",
-+					                     (duk_heaphdr *) key, (unsigned long) desc.flags,
-+					                     (void *) desc.get, (void *) desc.set));
-+					/* XXX: Extensibility check for target uses IsExtensible().  If we
-+					 * implemented the isExtensible trap and didn't reject proxies as
-+					 * proxy targets, it should be respected here.
-+					 */
-+					if (!((desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&  /* property is configurable and */
-+					      DUK_HOBJECT_HAS_EXTENSIBLE(h_target))) {          /* ... target is extensible */
-+						DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED);
-+					}
-+				}
-+			}
-+
-+			duk_pop_2(ctx);  /* [ key trap_result ] -> [] */
-+			return tmp_bool;
-+		}
-+
-+		obj = h_target;  /* resume check from proxy target */
-+	}
-+#endif  /* DUK_USE_ES6_PROXY */
-+
-+	/* XXX: inline into a prototype walking loop? */
-+
-+	rc = duk__get_property_desc(thr, obj, key, &desc, 0 /*flags*/);  /* don't push value */
-+	/* fall through */
-+
-+ pop_and_return:
-+	duk_pop(ctx);  /* [ key ] -> [] */
-+	return rc;
-+}
-+
-+/*
-+ *  HASPROP variant used internally.
-+ *
-+ *  This primitive must never throw an error, callers rely on this.
-+ *  In particular, don't throw an error for prototype loops; instead,
-+ *  pretend like the property doesn't exist if a prototype sanity limit
-+ *  is reached.
-+ *
-+ *  Does not implement proxy behavior: if applied to a proxy object,
-+ *  returns key existence on the proxy object itself.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_hasprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key) {
-+	duk_propdesc dummy;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	return duk__get_property_desc(thr, obj, key, &dummy, DUK__DESC_FLAG_IGNORE_PROTOLOOP);  /* don't push value */
-+}
-+
-+/*
-+ *  Helper: handle Array object 'length' write which automatically
-+ *  deletes properties, see E5 Section 15.4.5.1, step 3.  This is
-+ *  quite tricky to get right.
-+ *
-+ *  Used by duk_hobject_putprop().
-+ */
-+
-+DUK_LOCAL duk_uint32_t duk__get_old_array_length(duk_hthread *thr, duk_hobject *obj, duk_propdesc *temp_desc) {
-+	duk_bool_t rc;
-+	duk_tval *tv;
-+	duk_uint32_t res;
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/* This function is only called for objects with array exotic behavior.
-+	 * The [[DefineOwnProperty]] algorithm for arrays requires that
-+	 * 'length' can never have a value outside the unsigned 32-bit range,
-+	 * attempt to write such a value is a RangeError.  Here we can thus
-+	 * assert for this.  When Duktape internals go around the official
-+	 * property write interface (doesn't happen often) this assumption is
-+	 * easy to accidentally break, so such code must be written carefully.
-+	 * See test-bi-array-push-maxlen.js.
-+	 */
-+
-+	rc = duk__get_own_property_desc_raw(thr, obj, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, temp_desc, 0 /*flags*/);  /* don't push value */
-+	DUK_UNREF(rc);
-+	DUK_ASSERT(rc != 0);  /* arrays MUST have a 'length' property */
-+	DUK_ASSERT(temp_desc->e_idx >= 0);
-+
-+	tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, temp_desc->e_idx);
-+	DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));  /* array 'length' is always a number, as we coerce it */
-+	DUK_ASSERT(DUK_TVAL_GET_NUMBER(tv) >= 0.0);
-+	DUK_ASSERT(DUK_TVAL_GET_NUMBER(tv) <= (double) 0xffffffffUL);
-+	DUK_ASSERT((duk_double_t) (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv) == DUK_TVAL_GET_NUMBER(tv));
-+#if defined(DUK_USE_FASTINT)
-+	/* Downgrade checks are not made everywhere, so 'length' is not always
-+	 * a fastint (it is a number though).  This can be removed once length
-+	 * is always guaranteed to be a fastint.
-+	 */
-+	DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv) || DUK_TVAL_IS_DOUBLE(tv));
-+	if (DUK_TVAL_IS_FASTINT(tv)) {
-+		res = (duk_uint32_t) DUK_TVAL_GET_FASTINT_U32(tv);
-+	} else {
-+		res = (duk_uint32_t) DUK_TVAL_GET_DOUBLE(tv);
-+	}
-+#else
-+	res = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv);
-+#endif  /* DUK_USE_FASTINT */
-+
-+	return res;
-+}
-+
-+DUK_LOCAL duk_uint32_t duk__to_new_array_length_checked(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_uint32_t res;
-+	duk_double_t d;
-+
-+	/* Input value should be on stack top and will be coerced and
-+	 * popped.  Refuse to update an Array's 'length' to a value
-+	 * outside the 32-bit range.  Negative zero is accepted as zero.
-+	 */
-+
-+	/* XXX: fastint */
-+
-+	d = duk_to_number(ctx, -1);
-+	res = (duk_uint32_t) d;
-+	if ((duk_double_t) res != d) {
-+		DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_INVALID_ARRAY_LENGTH);
-+	}
-+	duk_pop(ctx);
-+	return res;
-+}
-+
-+/* Delete elements required by a smaller length, taking into account
-+ * potentially non-configurable elements.  Returns non-zero if all
-+ * elements could be deleted, and zero if all or some elements could
-+ * not be deleted.  Also writes final "target length" to 'out_result_len'.
-+ * This is the length value that should go into the 'length' property
-+ * (must be set by the caller).  Never throws an error.
-+ */
-+DUK_LOCAL
-+duk_bool_t duk__handle_put_array_length_smaller(duk_hthread *thr,
-+                                                duk_hobject *obj,
-+                                                duk_uint32_t old_len,
-+                                                duk_uint32_t new_len,
-+                                                duk_bool_t force_flag,
-+                                                duk_uint32_t *out_result_len) {
-+	duk_uint32_t target_len;
-+	duk_uint_fast32_t i;
-+	duk_uint32_t arr_idx;
-+	duk_hstring *key;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_bool_t rc;
-+
-+	DUK_DDD(DUK_DDDPRINT("new array length smaller than old (%ld -> %ld), "
-+	                     "probably need to remove elements",
-+	                     (long) old_len, (long) new_len));
-+
-+	/*
-+	 *  New length is smaller than old length, need to delete properties above
-+	 *  the new length.
-+	 *
-+	 *  If array part exists, this is straightforward: array entries cannot
-+	 *  be non-configurable so this is guaranteed to work.
-+	 *
-+	 *  If array part does not exist, array-indexed values are scattered
-+	 *  in the entry part, and some may not be configurable (preventing length
-+	 *  from becoming lower than their index + 1).  To handle the algorithm
-+	 *  in E5 Section 15.4.5.1, step l correctly, we scan the entire property
-+	 *  set twice.
-+	 */
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(new_len < old_len);
-+	DUK_ASSERT(out_result_len != NULL);
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
-+		/*
-+		 *  All defined array-indexed properties are in the array part
-+		 *  (we assume the array part is comprehensive), and all array
-+		 *  entries are writable, configurable, and enumerable.  Thus,
-+		 *  nothing can prevent array entries from being deleted.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("have array part, easy case"));
-+
-+		if (old_len < DUK_HOBJECT_GET_ASIZE(obj)) {
-+			/* XXX: assertion that entries >= old_len are already unused */
-+			i = old_len;
-+		} else {
-+			i = DUK_HOBJECT_GET_ASIZE(obj);
-+		}
-+		DUK_ASSERT(i <= DUK_HOBJECT_GET_ASIZE(obj));
-+
-+		while (i > new_len) {
-+			i--;
-+			tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+			DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);
-+		}
-+
-+		*out_result_len = new_len;
-+		return 1;
-+	} else {
-+		/*
-+		 *  Entries part is a bit more complex
-+		 */
-+
-+		/* Stage 1: find highest preventing non-configurable entry (if any).
-+		 * When forcing, ignore non-configurability.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("no array part, slow case"));
-+
-+		DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 1: find target_len "
-+		                     "(highest preventing non-configurable entry (if any))"));
-+
-+		target_len = new_len;
-+		if (force_flag) {
-+			DUK_DDD(DUK_DDDPRINT("array length write, no array part; force flag -> skip stage 1"));
-+			goto skip_stage1;
-+		}
-+		for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
-+			key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
-+			if (!key) {
-+				DUK_DDD(DUK_DDDPRINT("skip entry index %ld: null key", (long) i));
-+				continue;
-+			}
-+			if (!DUK_HSTRING_HAS_ARRIDX(key)) {
-+				DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key not an array index", (long) i));
-+				continue;
-+			}
-+
-+			DUK_ASSERT(DUK_HSTRING_HAS_ARRIDX(key));  /* XXX: macro checks for array index flag, which is unnecessary here */
-+			arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
-+			DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX);
-+			DUK_ASSERT(arr_idx < old_len);  /* consistency requires this */
-+
-+			if (arr_idx < new_len) {
-+				DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is array index %ld, below new_len",
-+				                     (long) i, (long) arr_idx));
-+				continue;
-+			}
-+			if (DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(thr->heap, obj, i)) {
-+				DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is a relevant array index %ld, but configurable",
-+				                     (long) i, (long) arr_idx));
-+				continue;
-+			}
-+
-+			/* relevant array index is non-configurable, blocks write */
-+			if (arr_idx >= target_len) {
-+				DUK_DDD(DUK_DDDPRINT("entry at index %ld has arr_idx %ld, is not configurable, "
-+				                     "update target_len %ld -> %ld",
-+				                     (long) i, (long) arr_idx, (long) target_len,
-+				                     (long) (arr_idx + 1)));
-+				target_len = arr_idx + 1;
-+			}
-+		}
-+	 skip_stage1:
-+
-+		/* stage 2: delete configurable entries above target length */
-+
-+		DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld, target_len=%ld",
-+		                     (long) old_len, (long) new_len, (long) target_len));
-+
-+		DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 2: remove "
-+		                     "entries >= target_len"));
-+
-+		for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
-+			key = DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i);
-+			if (!key) {
-+				DUK_DDD(DUK_DDDPRINT("skip entry index %ld: null key", (long) i));
-+				continue;
-+			}
-+			if (!DUK_HSTRING_HAS_ARRIDX(key)) {
-+				DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key not an array index", (long) i));
-+				continue;
-+			}
-+
-+			DUK_ASSERT(DUK_HSTRING_HAS_ARRIDX(key));  /* XXX: macro checks for array index flag, which is unnecessary here */
-+			arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
-+			DUK_ASSERT(arr_idx != DUK__NO_ARRAY_INDEX);
-+			DUK_ASSERT(arr_idx < old_len);  /* consistency requires this */
-+
-+			if (arr_idx < target_len) {
-+				DUK_DDD(DUK_DDDPRINT("skip entry index %ld: key is array index %ld, below target_len",
-+				                     (long) i, (long) arr_idx));
-+				continue;
-+			}
-+			DUK_ASSERT(force_flag || DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(thr->heap, obj, i));  /* stage 1 guarantees */
-+
-+			DUK_DDD(DUK_DDDPRINT("delete entry index %ld: key is array index %ld",
-+			                     (long) i, (long) arr_idx));
-+
-+			/*
-+			 *  Slow delete, but we don't care as we're already in a very slow path.
-+			 *  The delete always succeeds: key has no exotic behavior, property
-+			 *  is configurable, and no resize occurs.
-+			 */
-+			rc = duk_hobject_delprop_raw(thr, obj, key, force_flag ? DUK_DELPROP_FLAG_FORCE : 0);
-+			DUK_UNREF(rc);
-+			DUK_ASSERT(rc != 0);
-+		}
-+
-+		/* stage 3: update length (done by caller), decide return code */
-+
-+		DUK_DDD(DUK_DDDPRINT("array length write, no array part, stage 3: update length (done by caller)"));
-+
-+		*out_result_len = target_len;
-+
-+		if (target_len == new_len) {
-+			DUK_DDD(DUK_DDDPRINT("target_len matches new_len, return success"));
-+			return 1;
-+		}
-+		DUK_DDD(DUK_DDDPRINT("target_len does not match new_len (some entry prevented "
-+		                     "full length adjustment), return error"));
-+		return 0;
-+	}
-+
-+	DUK_UNREACHABLE();
-+}
-+
-+/* XXX: is valstack top best place for argument? */
-+DUK_LOCAL duk_bool_t duk__handle_put_array_length(duk_hthread *thr, duk_hobject *obj) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_propdesc desc;
-+	duk_uint32_t old_len;
-+	duk_uint32_t new_len;
-+	duk_uint32_t result_len;
-+	duk_tval *tv;
-+	duk_bool_t rc;
-+
-+	DUK_DDD(DUK_DDDPRINT("handling a put operation to array 'length' exotic property, "
-+	                     "new val: %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(obj != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	DUK_ASSERT(duk_is_valid_index(ctx, -1));
-+
-+	/*
-+	 *  Get old and new length
-+	 */
-+
-+	old_len = duk__get_old_array_length(thr, obj, &desc);
-+	duk_dup(ctx, -1);  /* [in_val in_val] */
-+	new_len = duk__to_new_array_length_checked(thr);  /* -> [in_val] */
-+	DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld", (long) old_len, (long) new_len));
-+
-+	/*
-+	 *  Writability check
-+	 */
-+
-+	if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
-+		DUK_DDD(DUK_DDDPRINT("length is not writable, fail"));
-+		return 0;
-+	}
-+
-+	/*
-+	 *  New length not lower than old length => no changes needed
-+	 *  (not even array allocation).
-+	 */
-+
-+	if (new_len >= old_len) {
-+		DUK_DDD(DUK_DDDPRINT("new length is higher than old length, just update length, no deletions"));
-+
-+		DUK_ASSERT(desc.e_idx >= 0);
-+		DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx));
-+		tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		/* no decref needed for a number */
-+#if defined(DUK_USE_FASTINT)
-+		DUK_TVAL_SET_FASTINT_U32(tv, new_len);
-+#else
-+		DUK_TVAL_SET_NUMBER(tv, (duk_double_t) new_len);
-+#endif
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		return 1;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("new length is lower than old length, probably must delete entries"));
-+
-+	/*
-+	 *  New length lower than old length => delete elements, then
-+	 *  update length.
-+	 *
-+	 *  Note: even though a bunch of elements have been deleted, the 'desc' is
-+	 *  still valid as properties haven't been resized (and entries compacted).
-+	 */
-+
-+	rc = duk__handle_put_array_length_smaller(thr, obj, old_len, new_len, 0 /*force_flag*/, &result_len);
-+	DUK_ASSERT(result_len >= new_len && result_len <= old_len);
-+
-+	DUK_ASSERT(desc.e_idx >= 0);
-+	DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx));
-+	tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
-+	DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+	/* no decref needed for a number */
-+#if defined(DUK_USE_FASTINT)
-+	DUK_TVAL_SET_FASTINT_U32(tv, result_len);
-+#else
-+	DUK_TVAL_SET_NUMBER(tv, (duk_double_t) result_len);
-+#endif
-+	DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+
-+	/* XXX: shrink array allocation or entries compaction here? */
-+
-+	return rc;
-+}
-+
-+/*
-+ *  PUTPROP: Ecmascript property write.
-+ *
-+ *  Unlike Ecmascript primitive which returns nothing, returns 1 to indicate
-+ *  success and 0 to indicate failure (assuming throw is not set).
-+ *
-+ *  This is an extremely tricky function.  Some examples:
-+ *
-+ *    * Currently a decref may trigger a GC, which may compact an object's
-+ *      property allocation.  Consequently, any entry indices (e_idx) will
-+ *      be potentially invalidated by a decref.
-+ *
-+ *    * Exotic behaviors (strings, arrays, arguments object) require,
-+ *      among other things:
-+ *
-+ *      - Preprocessing before and postprocessing after an actual property
-+ *        write.  For example, array index write requires pre-checking the
-+ *        array 'length' property for access control, and may require an
-+ *        array 'length' update after the actual write has succeeded (but
-+ *        not if it fails).
-+ *
-+ *      - Deletion of multiple entries, as a result of array 'length' write.
-+ *
-+ *    * Input values are taken as pointers which may point to the valstack.
-+ *      If valstack is resized because of the put (this may happen at least
-+ *      when the array part is abandoned), the pointers can be invalidated.
-+ *      (We currently make a copy of all of the input values to avoid issues.)
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_putprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_tval *tv_val, duk_bool_t throw_flag) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval tv_obj_copy;
-+	duk_tval tv_key_copy;
-+	duk_tval tv_val_copy;
-+	duk_hobject *orig = NULL;  /* NULL if tv_obj is primitive */
-+	duk_hobject *curr;
-+	duk_hstring *key = NULL;
-+	duk_propdesc desc;
-+	duk_tval *tv;
-+	duk_uint32_t arr_idx;
-+	duk_bool_t rc;
-+	duk_int_t e_idx;
-+	duk_uint_t sanity;
-+	duk_uint32_t new_array_length = 0;  /* 0 = no update */
-+
-+	DUK_DDD(DUK_DDDPRINT("putprop: thr=%p, obj=%p, key=%p, val=%p, throw=%ld "
-+	                     "(obj -> %!T, key -> %!T, val -> %!T)",
-+	                     (void *) thr, (void *) tv_obj, (void *) tv_key, (void *) tv_val,
-+	                     (long) throw_flag, (duk_tval *) tv_obj, (duk_tval *) tv_key, (duk_tval *) tv_val));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(tv_obj != NULL);
-+	DUK_ASSERT(tv_key != NULL);
-+	DUK_ASSERT(tv_val != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/*
-+	 *  Make a copy of tv_obj, tv_key, and tv_val to avoid any issues of
-+	 *  them being invalidated by a valstack resize.
-+	 *
-+	 *  XXX: this is an overkill for some paths, so optimize this later
-+	 *  (or maybe switch to a stack arguments model entirely).
-+	 */
-+
-+	DUK_TVAL_SET_TVAL(&tv_obj_copy, tv_obj);
-+	DUK_TVAL_SET_TVAL(&tv_key_copy, tv_key);
-+	DUK_TVAL_SET_TVAL(&tv_val_copy, tv_val);
-+	tv_obj = &tv_obj_copy;
-+	tv_key = &tv_key_copy;
-+	tv_val = &tv_val_copy;
-+
-+	/*
-+	 *  Coercion and fast path processing.
-+	 */
-+
-+	switch (DUK_TVAL_GET_TAG(tv_obj)) {
-+	case DUK_TAG_UNDEFINED:
-+	case DUK_TAG_NULL: {
-+		/* Note: unconditional throw */
-+		DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject (object=%!iT)",
-+		                     (duk_tval *) tv_obj));
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE);
-+		return 0;
-+	}
-+
-+	case DUK_TAG_BOOLEAN: {
-+		DUK_DDD(DUK_DDDPRINT("base object is a boolean, start lookup from boolean prototype"));
-+		curr = thr->builtins[DUK_BIDX_BOOLEAN_PROTOTYPE];
-+		break;
-+	}
-+
-+	case DUK_TAG_STRING: {
-+		duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
-+
-+		/*
-+		 *  Note: currently no fast path for array index writes.
-+		 *  They won't be possible anyway as strings are immutable.
-+		 */
-+
-+		DUK_ASSERT(key == NULL);
-+		arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+		DUK_ASSERT(key != NULL);
-+
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			goto fail_not_writable;
-+		}
-+
-+		if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+		    arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
-+			goto fail_not_writable;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("base object is a string, start lookup from string prototype"));
-+		curr = thr->builtins[DUK_BIDX_STRING_PROTOTYPE];
-+		goto lookup;  /* avoid double coercion */
-+	}
-+
-+	case DUK_TAG_OBJECT: {
-+		orig = DUK_TVAL_GET_OBJECT(tv_obj);
-+		DUK_ASSERT(orig != NULL);
-+
-+		/* The fast path for array property put is not fully compliant:
-+		 * If one places conflicting number-indexed properties into
-+		 * Array.prototype (for example, a non-writable Array.prototype[7])
-+		 * the fast path will incorrectly ignore them.
-+		 *
-+		 * This fast path could be made compliant by falling through
-+		 * to the slow path if the previous value was UNDEFINED_UNUSED.
-+		 * This would also remove the need to check for extensibility.
-+		 * Right now a non-extensible array is slower than an extensible
-+		 * one as far as writes are concerned.
-+		 *
-+		 * The fast path behavior is documented in more detail here:
-+		 * ecmascript-testcases/test-misc-array-fast-write.js
-+		 */
-+
-+		if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
-+		    DUK_HOBJECT_HAS_ARRAY_PART(orig) &&
-+		    DUK_HOBJECT_HAS_EXTENSIBLE(orig) &&
-+		    DUK_TVAL_IS_NUMBER(tv_key)) {
-+			arr_idx = duk__tval_number_to_arr_idx(tv_key);
-+			if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+			    arr_idx < DUK_HOBJECT_GET_ASIZE(orig)) {  /* for resizing of array part, use slow path */
-+				duk_tval tv_tmp;
-+				duk_uint32_t old_len, new_len;
-+
-+				DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(orig));
-+
-+				old_len = duk__get_old_array_length(thr, orig, &desc);
-+
-+				if (arr_idx >= old_len) {
-+					DUK_DDD(DUK_DDDPRINT("write new array entry requires length update "
-+					                     "(arr_idx=%ld, old_len=%ld)",
-+					                     (long) arr_idx, (long) old_len));
-+					if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
-+						DUK_DD(DUK_DDPRINT("attempt to extend array, but array 'length' is not writable"));
-+						goto fail_not_writable;
-+					}
-+					new_len = arr_idx + 1;
-+
-+					/* No resize has occurred so desc.e_idx is still OK */
-+					tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx);
-+					DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+#if defined(DUK_USE_FASTINT)
-+					DUK_TVAL_SET_FASTINT_U32(tv, new_len);  /* no need for decref/incref because value is a number */
-+#else
-+					DUK_TVAL_SET_NUMBER(tv, (duk_double_t) new_len);  /* no need for decref/incref because value is a number */
-+#endif
-+				} else {
-+					;
-+				}
-+
-+				tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, arr_idx);
-+				DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+				DUK_TVAL_SET_TVAL(tv, tv_val);
-+				DUK_TVAL_INCREF(thr, tv);
-+				DUK_TVAL_DECREF(thr, &tv_tmp);  /* note: may trigger gc and props compaction, must be last */
-+
-+				DUK_DDD(DUK_DDDPRINT("array fast path success for index %ld", (long) arr_idx));
-+				return 1;
-+			}
-+		}
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+		if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(orig))) {
-+			duk_hobject *h_target;
-+			duk_bool_t tmp_bool;
-+
-+			if (duk__proxy_check_prop(thr, orig, DUK_STRIDX_SET, tv_key, &h_target)) {
-+				/* -> [ ... trap handler ] */
-+				DUK_DDD(DUK_DDDPRINT("-> proxy object 'set' for key %!T", (duk_tval *) tv_key));
-+				duk_push_hobject(ctx, h_target);  /* target */
-+				duk_push_tval(ctx, tv_key);       /* P */
-+				duk_push_tval(ctx, tv_val);       /* V */
-+				duk_push_tval(ctx, tv_obj);       /* Receiver: Proxy object */
-+				duk_call_method(ctx, 4 /*nargs*/);
-+				tmp_bool = duk_to_boolean(ctx, -1);
-+				duk_pop(ctx);
-+				if (!tmp_bool) {
-+					goto fail_proxy_rejected;
-+				}
-+
-+				/* Target object must be checked for a conflicting
-+				 * non-configurable property.
-+				 */
-+				arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+				DUK_ASSERT(key != NULL);
-+
-+				if (duk__get_own_property_desc_raw(thr, h_target, key, arr_idx, &desc, DUK__DESC_FLAG_PUSH_VALUE)) {
-+					duk_tval *tv_targ = duk_require_tval(ctx, -1);
-+					duk_bool_t datadesc_reject;
-+					duk_bool_t accdesc_reject;
-+
-+					DUK_DDD(DUK_DDDPRINT("proxy 'set': target has matching property %!O, check for "
-+					                     "conflicting property; tv_val=%!T, tv_targ=%!T, desc.flags=0x%08lx, "
-+					                     "desc.get=%p, desc.set=%p",
-+					                     (duk_heaphdr *) key, (duk_tval *) tv_val, (duk_tval *) tv_targ,
-+					                     (unsigned long) desc.flags,
-+					                     (void *) desc.get, (void *) desc.set));
-+
-+					datadesc_reject = !(desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
-+					                  !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&
-+					                  !(desc.flags & DUK_PROPDESC_FLAG_WRITABLE) &&
-+					                  !duk_js_samevalue(tv_val, tv_targ);
-+					accdesc_reject = (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
-+					                 !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) &&
-+					                 (desc.set == NULL);
-+					if (datadesc_reject || accdesc_reject) {
-+						DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED);
-+					}
-+
-+					duk_pop_2(ctx);
-+				} else {
-+					duk_pop(ctx);
-+				}
-+				return 1;  /* success */
-+			}
-+
-+			orig = h_target;  /* resume write to target */
-+			DUK_TVAL_SET_OBJECT(tv_obj, orig);
-+		}
-+#endif  /* DUK_USE_ES6_PROXY */
-+
-+		curr = orig;
-+		break;
-+	}
-+
-+	case DUK_TAG_BUFFER: {
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
-+		duk_int_t pop_count = 0;
-+
-+		/*
-+		 *  Because buffer values may be looped over and read/written
-+		 *  from, an array index fast path is important.
-+		 */
-+
-+#if defined(DUK_USE_FASTINT)
-+		if (DUK_TVAL_IS_FASTINT(tv_key)) {
-+			arr_idx = duk__tval_fastint_to_arr_idx(tv_key);
-+			DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path fastint; arr_idx %ld", (long) arr_idx));
-+			pop_count = 0;
-+		} else
-+#endif
-+		if (DUK_TVAL_IS_NUMBER(tv_key)) {
-+			arr_idx = duk__tval_number_to_arr_idx(tv_key);
-+			DUK_DDD(DUK_DDDPRINT("base object buffer, key is a fast-path number; arr_idx %ld", (long) arr_idx));
-+			pop_count = 0;
-+		} else {
-+			arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+			DUK_ASSERT(key != NULL);
-+			DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
-+			                     "coercion key is %!T, arr_idx %ld",
-+			                     (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
-+			pop_count = 1;
-+		}
-+
-+		if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+		    arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
-+			duk_uint8_t *data;
-+			DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx));
-+			data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);
-+
-+			/* XXX: duk_to_int() ensures we'll get 8 lowest bits as
-+			 * as input is within duk_int_t range (capped outside it).
-+			 */
-+#if defined(DUK_USE_FASTINT)
-+			/* Buffer writes are often integers. */
-+			if (DUK_TVAL_IS_FASTINT(tv_val)) {
-+				data[arr_idx] = (duk_uint8_t) DUK_TVAL_GET_FASTINT_U32(tv_val);
-+			}
-+			else
-+#endif
-+			{
-+				duk_push_tval(ctx, tv_val);
-+				data[arr_idx] = (duk_uint8_t) duk_to_int(ctx, -1);
-+				pop_count++;
-+			}
-+
-+			duk_pop_n(ctx, pop_count);
-+			DUK_DDD(DUK_DDDPRINT("result: success (buffer data write)"));
-+			return 1;
-+		}
-+
-+		if (pop_count == 0) {
-+			/* This is a pretty awkward control flow, but we need to recheck the
-+			 * key coercion here.
-+			 */
-+			arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+			DUK_ASSERT(key != NULL);
-+			DUK_DDD(DUK_DDDPRINT("base object buffer, key is a non-fast-path number; after "
-+			                     "coercion key is %!T, arr_idx %ld",
-+			                     (duk_tval *) duk_get_tval(ctx, -1), (long) arr_idx));
-+		}
-+
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			goto fail_not_writable;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("base object is a buffer, start lookup from buffer prototype"));
-+		curr = thr->builtins[DUK_BIDX_BUFFER_PROTOTYPE];
-+		goto lookup;  /* avoid double coercion */
-+	}
-+
-+	case DUK_TAG_POINTER: {
-+		DUK_DDD(DUK_DDDPRINT("base object is a pointer, start lookup from pointer prototype"));
-+		curr = thr->builtins[DUK_BIDX_POINTER_PROTOTYPE];
-+		break;
-+	}
-+
-+	case DUK_TAG_LIGHTFUNC: {
-+		/* All lightfunc own properties are non-writable and the lightfunc
-+		 * is considered non-extensible.  However, the write may be captured
-+		 * by an inherited setter which means we can't stop the lookup here.
-+		 */
-+
-+		arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+
-+		if (duk__key_is_lightfunc_ownprop(thr, key)) {
-+			goto fail_not_writable;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("base object is a lightfunc, start lookup from function prototype"));
-+		curr = thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE];
-+		goto lookup;  /* avoid double coercion */
-+	}
-+
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default: {
-+		/* number */
-+		DUK_DDD(DUK_DDDPRINT("base object is a number, start lookup from number prototype"));
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_obj));
-+		curr = thr->builtins[DUK_BIDX_NUMBER_PROTOTYPE];
-+		break;
-+	}
-+	}
-+
-+	DUK_ASSERT(key == NULL);
-+	arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+	DUK_ASSERT(key != NULL);
-+
-+ lookup:
-+
-+	/*
-+	 *  Check whether the property already exists in the prototype chain.
-+	 *  Note that the actual write goes into the original base object
-+	 *  (except if an accessor property captures the write).
-+	 */
-+
-+	/* [key] */
-+
-+	DUK_ASSERT(curr != NULL);
-+	sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
-+	do {
-+		if (!duk__get_own_property_desc_raw(thr, curr, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
-+			goto next_in_chain;
-+		}
-+
-+		if (desc.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+			/*
-+			 *  Found existing accessor property (own or inherited).
-+			 *  Call setter with 'this' set to orig, and value as the only argument.
-+			 *
-+			 *  Note: no exotic arguments object behavior, because [[Put]] never
-+			 *  calls [[DefineOwnProperty]] (E5 Section 8.12.5, step 5.b).
-+			 */
-+
-+			duk_hobject *setter;
-+
-+			DUK_DD(DUK_DDPRINT("put to an own or inherited accessor, calling setter"));
-+
-+			setter = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, curr, desc.e_idx);
-+			if (!setter) {
-+				goto fail_no_setter;
-+			}
-+			duk_push_hobject(ctx, setter);
-+			duk_push_tval(ctx, tv_obj);  /* note: original, uncoerced base */
-+			duk_push_tval(ctx, tv_val);  /* [key setter this val] */
-+#ifdef DUK_USE_NONSTD_SETTER_KEY_ARGUMENT
-+			duk_dup(ctx, -4);
-+			duk_call_method(ctx, 2);     /* [key setter this val key] -> [key retval] */
-+#else
-+			duk_call_method(ctx, 1);     /* [key setter this val] -> [key retval] */
-+#endif
-+			duk_pop(ctx);                /* ignore retval -> [key] */
-+			goto success_no_arguments_exotic;
-+		}
-+
-+		if (orig == NULL) {
-+			/*
-+			 *  Found existing own or inherited plain property, but original
-+			 *  base is a primitive value.
-+			 */
-+			DUK_DD(DUK_DDPRINT("attempt to create a new property in a primitive base object"));
-+			goto fail_base_primitive;
-+		}
-+
-+		if (curr != orig) {
-+			/*
-+			 *  Found existing inherited plain property.
-+			 *  Do an access control check, and if OK, write
-+			 *  new property to 'orig'.
-+			 */
-+			if (!DUK_HOBJECT_HAS_EXTENSIBLE(orig)) {
-+				DUK_DD(DUK_DDPRINT("found existing inherited plain property, but original object is not extensible"));
-+				goto fail_not_extensible;
-+			}
-+			if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
-+				DUK_DD(DUK_DDPRINT("found existing inherited plain property, original object is extensible, but inherited property is not writable"));
-+				goto fail_not_writable;
-+			}
-+			DUK_DD(DUK_DDPRINT("put to new property, object extensible, inherited property found and is writable"));
-+			goto create_new;
-+		} else {
-+			/*
-+			 *  Found existing own (non-inherited) plain property.
-+			 *  Do an access control check and update in place.
-+			 */
-+
-+			if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
-+				DUK_DD(DUK_DDPRINT("found existing own (non-inherited) plain property, but property is not writable"));
-+				goto fail_not_writable;
-+			}
-+			if (desc.flags & DUK_PROPDESC_FLAG_VIRTUAL) {
-+				DUK_DD(DUK_DDPRINT("found existing own (non-inherited) virtual property, property is writable"));
-+				if (DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(curr)) {
-+					duk_hbuffer *h;
-+
-+					DUK_DD(DUK_DDPRINT("writable virtual property is in buffer object"));
-+					h = duk_hobject_get_internal_value_buffer(thr->heap, curr);
-+					DUK_ASSERT(h != NULL);
-+
-+					if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+					    arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
-+						duk_uint8_t *data;
-+						DUK_DDD(DUK_DDDPRINT("writing to buffer data at index %ld", (long) arr_idx));
-+						data = (duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h);
-+						duk_push_tval(ctx, tv_val);
-+						/* XXX: duk_to_int() ensures we'll get 8 lowest bits as
-+						 * as input is within duk_int_t range (capped outside it).
-+						 */
-+						data[arr_idx] = (duk_uint8_t) duk_to_int(ctx, -1);
-+						duk_pop(ctx);
-+						goto success_no_arguments_exotic;
-+					}
-+				}
-+
-+				goto fail_internal;  /* should not happen */
-+			}
-+			DUK_DD(DUK_DDPRINT("put to existing own plain property, property is writable"));
-+			goto update_old;
-+		}
-+		DUK_UNREACHABLE();
-+
-+	 next_in_chain:
-+		/* XXX: option to pretend property doesn't exist if sanity limit is
-+		 * hit might be useful.
-+		 */
-+		if (sanity-- == 0) {
-+			DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
-+		}
-+		curr = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, curr);
-+	} while (curr);
-+
-+	/*
-+	 *  Property not found in prototype chain.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("property not found in prototype chain"));
-+
-+	if (orig == NULL) {
-+		DUK_DD(DUK_DDPRINT("attempt to create a new property in a primitive base object"));
-+		goto fail_base_primitive;
-+	}
-+
-+	if (!DUK_HOBJECT_HAS_EXTENSIBLE(orig)) {
-+		DUK_DD(DUK_DDPRINT("put to a new property (not found in prototype chain), but original object not extensible"));
-+		goto fail_not_extensible;
-+	}
-+
-+	goto create_new;
-+
-+ update_old:
-+
-+	/*
-+	 *  Update an existing property of the base object.
-+	 */
-+
-+	/* [key] */
-+
-+	DUK_DDD(DUK_DDDPRINT("update an existing property of the original object"));
-+
-+	DUK_ASSERT(orig != NULL);
-+
-+	/* Although there are writable virtual properties (e.g. plain buffer
-+	 * and buffer object number indices), they are handled before we come
-+	 * here.
-+	 */
-+	DUK_ASSERT((desc.flags & DUK_PROPDESC_FLAG_VIRTUAL) == 0);
-+	DUK_ASSERT(desc.a_idx >= 0 || desc.e_idx >= 0);
-+
-+	if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
-+	    key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+		/*
-+		 *  Write to 'length' of an array is a very complex case
-+		 *  handled in a helper which updates both the array elements
-+		 *  and writes the new 'length'.  The write may result in an
-+		 *  unconditional RangeError or a partial write (indicated
-+		 *  by a return code).
-+		 *
-+		 *  Note: the helper has an unnecessary writability check
-+		 *  for 'length', we already know it is writable.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("writing existing 'length' property to array exotic, invoke complex helper"));
-+
-+		/* XXX: the helper currently assumes stack top contains new
-+		 * 'length' value and the whole calling convention is not very
-+		 * compatible with what we need.
-+		 */
-+
-+		duk_push_tval(ctx, tv_val);  /* [key val] */
-+		rc = duk__handle_put_array_length(thr, orig);
-+		duk_pop(ctx);  /* [key val] -> [key] */
-+		if (!rc) {
-+			goto fail_array_length_partial;
-+		}
-+
-+		/* key is 'length', cannot match argument exotic behavior */
-+		goto success_no_arguments_exotic;
-+	}
-+
-+	if (desc.e_idx >= 0) {
-+		duk_tval tv_tmp;
-+
-+		tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx);
-+		DUK_DDD(DUK_DDDPRINT("previous entry value: %!iT", (duk_tval *) tv));
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+		DUK_TVAL_SET_TVAL(tv, tv_val);
-+		DUK_TVAL_INCREF(thr, tv);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);  /* note: may trigger gc and props compaction, must be last */
-+		/* don't touch property attributes or hash part */
-+		DUK_DD(DUK_DDPRINT("put to an existing entry at index %ld -> new value %!iT",
-+		                   (long) desc.e_idx, (duk_tval *) tv));
-+	} else {
-+		/* Note: array entries are always writable, so the writability check
-+		 * above is pointless for them.  The check could be avoided with some
-+		 * refactoring but is probably not worth it.
-+		 */
-+		duk_tval tv_tmp;
-+
-+		DUK_ASSERT(desc.a_idx >= 0);
-+		tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, desc.a_idx);
-+		DUK_DDD(DUK_DDDPRINT("previous array value: %!iT", (duk_tval *) tv));
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+		DUK_TVAL_SET_TVAL(tv, tv_val);
-+		DUK_TVAL_INCREF(thr, tv);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);  /* note: may trigger gc and props compaction, must be last */
-+		DUK_DD(DUK_DDPRINT("put to an existing array entry at index %ld -> new value %!iT",
-+		                   (long) desc.a_idx, (duk_tval *) tv));
-+	}
-+
-+	/* Regardless of whether property is found in entry or array part,
-+	 * it may have arguments exotic behavior (array indices may reside
-+	 * in entry part for abandoned / non-existent array parts).
-+	 */
-+	goto success_with_arguments_exotic;
-+
-+ create_new:
-+
-+	/*
-+	 *  Create a new property in the original object.
-+	 *
-+	 *  Exotic properties need to be reconsidered here from a write
-+	 *  perspective (not just property attributes perspective).
-+	 *  However, the property does not exist in the object already,
-+	 *  so this limits the kind of exotic properties that apply.
-+	 */
-+
-+	/* [key] */
-+
-+	DUK_DDD(DUK_DDDPRINT("create new property to original object"));
-+
-+	DUK_ASSERT(orig != NULL);
-+
-+	/* Not possible because array object 'length' is present
-+	 * from its creation and cannot be deleted, and is thus
-+	 * caught as an existing property above.
-+	 */
-+	DUK_ASSERT(!(DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
-+	             key == DUK_HTHREAD_STRING_LENGTH(thr)));
-+
-+	if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(orig) &&
-+	    arr_idx != DUK__NO_ARRAY_INDEX) {
-+		/* automatic length update */
-+		duk_uint32_t old_len;
-+
-+		old_len = duk__get_old_array_length(thr, orig, &desc);
-+
-+		if (arr_idx >= old_len) {
-+			DUK_DDD(DUK_DDDPRINT("write new array entry requires length update "
-+			                     "(arr_idx=%ld, old_len=%ld)",
-+			                     (long) arr_idx, (long) old_len));
-+
-+			if (!(desc.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
-+				DUK_DD(DUK_DDPRINT("attempt to extend array, but array 'length' is not writable"));
-+				goto fail_not_writable;
-+			}
-+
-+			/* Note: actual update happens once write has been completed
-+			 * without error below.  The write should always succeed
-+			 * from a specification viewpoint, but we may e.g. run out
-+			 * of memory.  It's safer in this order.
-+			 */
-+
-+			DUK_ASSERT(arr_idx != 0xffffffffUL);
-+			new_array_length = arr_idx + 1;  /* flag for later write */
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("write new array entry does not require length update "
-+			                     "(arr_idx=%ld, old_len=%ld)",
-+			                     (long) arr_idx, (long) old_len));
-+		}
-+	}
-+
-+ /* write_to_array_part: */
-+
-+	/*
-+	 *  Write to array part?
-+	 *
-+	 *  Note: array abandonding requires a property resize which uses
-+	 *  'rechecks' valstack for temporaries and may cause any existing
-+	 *  valstack pointers to be invalidated.  To protect against this,
-+	 *  tv_obj, tv_key, and tv_val are copies of the original inputs.
-+	 */
-+
-+	if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+	    DUK_HOBJECT_HAS_ARRAY_PART(orig)) {
-+		if (arr_idx < DUK_HOBJECT_GET_ASIZE(orig)) {
-+			goto no_array_growth;
-+		}
-+
-+		/*
-+		 *  Array needs to grow, but we don't want it becoming too sparse.
-+		 *  If it were to become sparse, abandon array part, moving all
-+		 *  array entries into the entries part (for good).
-+		 *
-+		 *  Since we don't keep track of actual density (used vs. size) of
-+		 *  the array part, we need to estimate somehow.  The check is made
-+		 *  in two parts:
-+		 *
-+		 *    - Check whether the resize need is small compared to the
-+		 *      current size (relatively); if so, resize without further
-+		 *      checking (essentially we assume that the original part is
-+		 *      "dense" so that the result would be dense enough).
-+		 *
-+		 *    - Otherwise, compute the resize using an actual density
-+		 *      measurement based on counting the used array entries.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("write to new array requires array resize, decide whether to do a "
-+		                     "fast resize without abandon check (arr_idx=%ld, old_size=%ld)",
-+		                     (long) arr_idx, (long) DUK_HOBJECT_GET_ASIZE(orig)));
-+
-+		if (duk__abandon_array_slow_check_required(arr_idx, DUK_HOBJECT_GET_ASIZE(orig))) {
-+			duk_uint32_t old_used;
-+			duk_uint32_t old_size;
-+
-+			DUK_DDD(DUK_DDDPRINT("=> fast check is NOT OK, do slow check for array abandon"));
-+
-+			duk__compute_a_stats(thr, orig, &old_used, &old_size);
-+
-+			DUK_DDD(DUK_DDDPRINT("abandon check, array stats: old_used=%ld, old_size=%ld, arr_idx=%ld",
-+			                     (long) old_used, (long) old_size, (long) arr_idx));
-+
-+			/* Note: intentionally use approximations to shave a few instructions:
-+			 *   a_used = old_used  (accurate: old_used + 1)
-+			 *   a_size = arr_idx   (accurate: arr_idx + 1)
-+			 */
-+			if (duk__abandon_array_density_check(old_used, arr_idx)) {
-+				DUK_DD(DUK_DDPRINT("write to new array entry beyond current length, "
-+				                   "decided to abandon array part (would become too sparse)"));
-+
-+				/* abandoning requires a props allocation resize and
-+				 * 'rechecks' the valstack, invalidating any existing
-+				 * valstack value pointers!
-+				 */
-+				duk__abandon_array_checked(thr, orig);
-+				DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(orig));
-+
-+				goto write_to_entry_part;
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("=> decided to keep array part"));
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("=> fast resize is OK"));
-+		}
-+
-+		DUK_DD(DUK_DDPRINT("write to new array entry beyond current length, "
-+		                   "decided to extend current allocation"));
-+
-+		duk__grow_props_for_array_item(thr, orig, arr_idx);
-+
-+	 no_array_growth:
-+
-+		/* Note: assume array part is comprehensive, so that either
-+		 * the write goes to the array part, or we've abandoned the
-+		 * array above (and will not come here).
-+		 */
-+
-+		DUK_ASSERT(DUK_HOBJECT_HAS_ARRAY_PART(orig));
-+		DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(orig));
-+
-+		tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, orig, arr_idx);
-+		/* prev value must be unused, no decref */
-+		DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv));
-+		DUK_TVAL_SET_TVAL(tv, tv_val);
-+		DUK_TVAL_INCREF(thr, tv);
-+		DUK_DD(DUK_DDPRINT("put to new array entry: %ld -> %!T",
-+		                   (long) arr_idx, (duk_tval *) tv));
-+
-+		/* Note: array part values are [[Writable]], [[Enumerable]],
-+		 * and [[Configurable]] which matches the required attributes
-+		 * here.
-+		 */
-+		goto entry_updated;
-+	}
-+
-+ write_to_entry_part:
-+
-+	/*
-+	 *  Write to entry part
-+	 */
-+
-+	/* entry allocation updates hash part and increases the key
-+	 * refcount; may need a props allocation resize but doesn't
-+	 * 'recheck' the valstack.
-+	 */
-+	e_idx = duk__alloc_entry_checked(thr, orig, key);
-+	DUK_ASSERT(e_idx >= 0);
-+
-+	tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, e_idx);
-+	/* prev value can be garbage, no decref */
-+	DUK_TVAL_SET_TVAL(tv, tv_val);
-+	DUK_TVAL_INCREF(thr, tv);
-+	DUK_HOBJECT_E_SET_FLAGS(thr->heap, orig, e_idx, DUK_PROPDESC_FLAGS_WEC);
-+	goto entry_updated;
-+
-+ entry_updated:
-+
-+	/*
-+	 *  Possible pending array length update, which must only be done
-+	 *  if the actual entry write succeeded.
-+	 */
-+
-+	if (new_array_length > 0) {
-+		/*
-+		 *  Note: zero works as a "no update" marker because the new length
-+		 *  can never be zero after a new property is written.
-+		 *
-+		 *  Note: must re-lookup because calls above (e.g. duk__alloc_entry_checked())
-+		 *  may realloc and compact properties and hence change e_idx.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("write successful, pending array length update to: %ld",
-+		                     (long) new_array_length));
-+
-+		rc = duk__get_own_property_desc_raw(thr, orig, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, &desc, 0 /*flags*/);  /* don't push value */
-+		DUK_UNREF(rc);
-+		DUK_ASSERT(rc != 0);
-+		DUK_ASSERT(desc.e_idx >= 0);
-+
-+		tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, orig, desc.e_idx);
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+		/* no need for decref/incref because value is a number */
-+#if defined(DUK_USE_FASTINT)
-+		DUK_TVAL_SET_FASTINT_U32(tv, new_array_length);
-+#else
-+		DUK_TVAL_SET_NUMBER(tv, (duk_double_t) new_array_length);
-+#endif
-+	}
-+
-+	/*
-+	 *  Arguments exotic behavior not possible for new properties: all
-+	 *  magically bound properties are initially present in the arguments
-+	 *  object, and if they are deleted, the binding is also removed from
-+	 *  parameter map.
-+	 */
-+
-+	goto success_no_arguments_exotic;
-+
-+ success_with_arguments_exotic:
-+
-+	/*
-+	 *  Arguments objects have exotic [[DefineOwnProperty]] which updates
-+	 *  the internal 'map' of arguments for writes to currently mapped
-+	 *  arguments.  More conretely, writes to mapped arguments generate
-+	 *  a write to a bound variable.
-+	 *
-+	 *  The [[Put]] algorithm invokes [[DefineOwnProperty]] for existing
-+	 *  data properties and new properties, but not for existing accessors.
-+	 *  Hence, in E5 Section 10.6 ([[DefinedOwnProperty]] algorithm), we
-+	 *  have a Desc with 'Value' (and possibly other properties too), and
-+	 *  we end up in step 5.b.i.
-+	 */
-+
-+	if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+	    DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(orig)) {
-+		/* Note: only numbered indices are relevant, so arr_idx fast reject
-+		 * is good (this is valid unless there are more than 4**32-1 arguments).
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("putprop successful, arguments exotic behavior needed"));
-+
-+		/* Note: we can reuse 'desc' here */
-+
-+		/* XXX: top of stack must contain value, which helper doesn't touch,
-+		 * rework to use tv_val directly?
-+		 */
-+
-+		duk_push_tval(ctx, tv_val);
-+		(void) duk__check_arguments_map_for_put(thr, orig, key, &desc, throw_flag);
-+		duk_pop(ctx);
-+	}
-+	/* fall thru */
-+
-+ success_no_arguments_exotic:
-+	/* shared exit path now */
-+	DUK_DDD(DUK_DDDPRINT("result: success"));
-+	duk_pop(ctx);  /* remove key */
-+	return 1;
-+
-+ fail_proxy_rejected:
-+	DUK_DDD(DUK_DDDPRINT("result: error, proxy rejects"));
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED);
-+	}
-+	/* Note: no key on stack */
-+	return 0;
-+
-+ fail_base_primitive:
-+	DUK_DDD(DUK_DDDPRINT("result: error, base primitive"));
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE);
-+	}
-+	duk_pop(ctx);  /* remove key */
-+	return 0;
-+
-+ fail_not_extensible:
-+	DUK_DDD(DUK_DDDPRINT("result: error, not extensible"));
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_EXTENSIBLE);
-+	}
-+	duk_pop(ctx);  /* remove key */
-+	return 0;
-+
-+ fail_not_writable:
-+	DUK_DDD(DUK_DDDPRINT("result: error, not writable"));
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_WRITABLE);
-+	}
-+	duk_pop(ctx);  /* remove key */
-+	return 0;
-+
-+ fail_array_length_partial:
-+	DUK_DDD(DUK_DDDPRINT("result: error, array length write only partially successful"));
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_ARRAY_LENGTH_WRITE_FAILED);
-+	}
-+	duk_pop(ctx);  /* remove key */
-+	return 0;
-+
-+ fail_no_setter:
-+	DUK_DDD(DUK_DDDPRINT("result: error, accessor property without setter"));
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_SETTER_UNDEFINED);
-+	}
-+	duk_pop(ctx);  /* remove key */
-+	return 0;
-+
-+ fail_internal:
-+	DUK_DDD(DUK_DDDPRINT("result: error, internal"));
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INTERNAL_ERROR);
-+	}
-+	duk_pop(ctx);  /* remove key */
-+	return 0;
-+}
-+
-+/*
-+ *  Ecmascript compliant [[Delete]](P, Throw).
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_delprop_raw(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags) {
-+	duk_propdesc desc;
-+	duk_tval *tv;
-+	duk_tval tv_tmp;
-+	duk_uint32_t arr_idx;
-+	duk_bool_t throw_flag;
-+	duk_bool_t force_flag;
-+
-+	throw_flag = (flags & DUK_DELPROP_FLAG_THROW);
-+	force_flag = (flags & DUK_DELPROP_FLAG_FORCE);
-+
-+	DUK_DDD(DUK_DDDPRINT("delprop_raw: thr=%p, obj=%p, key=%p, throw=%ld, force=%ld (obj -> %!O, key -> %!O)",
-+	                     (void *) thr, (void *) obj, (void *) key, (long) throw_flag, (long) force_flag,
-+	                     (duk_heaphdr *) obj, (duk_heaphdr *) key));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
-+
-+	/* 0 = don't push current value */
-+	if (!duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
-+		DUK_DDD(DUK_DDDPRINT("property not found, succeed always"));
-+		goto success;
-+	}
-+
-+	if ((desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) == 0 && !force_flag) {
-+		goto fail_not_configurable;
-+	}
-+	if (desc.a_idx < 0 && desc.e_idx < 0) {
-+		/* Currently there are no deletable virtual properties, but
-+		 * with force_flag we might attempt to delete one.
-+		 */
-+		goto fail_virtual;
-+	}
-+
-+	if (desc.a_idx >= 0) {
-+		DUK_ASSERT(desc.e_idx < 0);
-+
-+		tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx);
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+		DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);
-+		goto success;
-+	} else {
-+		DUK_ASSERT(desc.a_idx < 0);
-+
-+		/* remove hash entry (no decref) */
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+		if (desc.h_idx >= 0) {
-+			duk_uint32_t *h_base = DUK_HOBJECT_H_GET_BASE(thr->heap, obj);
-+
-+			DUK_DDD(DUK_DDDPRINT("removing hash entry at h_idx %ld", (long) desc.h_idx));
-+			DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) > 0);
-+			DUK_ASSERT((duk_uint32_t) desc.h_idx < DUK_HOBJECT_GET_HSIZE(obj));
-+			h_base[desc.h_idx] = DUK__HASH_DELETED;
-+		} else {
-+			DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) == 0);
-+		}
-+#else
-+		DUK_ASSERT(DUK_HOBJECT_GET_HSIZE(obj) == 0);
-+#endif
-+
-+		/* remove value */
-+		DUK_DDD(DUK_DDDPRINT("before removing value, e_idx %ld, key %p, key at slot %p",
-+		                     (long) desc.e_idx, (void *) key, (void *) DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx)));
-+		DUK_DDD(DUK_DDDPRINT("removing value at e_idx %ld", (long) desc.e_idx));
-+		if (DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx)) {
-+			duk_hobject *tmp;
-+
-+			tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, desc.e_idx);
-+			DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, desc.e_idx, NULL);
-+			DUK_UNREF(tmp);
-+			DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+
-+			tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, desc.e_idx);
-+			DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, desc.e_idx, NULL);
-+			DUK_UNREF(tmp);
-+			DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+		} else {
-+			tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+			DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);
-+		}
-+		/* this is not strictly necessary because if key == NULL, value MUST be ignored */
-+		DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, 0);
-+		DUK_TVAL_SET_UNDEFINED_UNUSED(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx));
-+
-+		/* remove key */
-+		DUK_DDD(DUK_DDDPRINT("before removing key, e_idx %ld, key %p, key at slot %p",
-+		                     (long) desc.e_idx, (void *) key, (void *) DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx)));
-+		DUK_DDD(DUK_DDDPRINT("removing key at e_idx %ld", (long) desc.e_idx));
-+		DUK_ASSERT(key == DUK_HOBJECT_E_GET_KEY(thr->heap, obj, desc.e_idx));
-+		DUK_HOBJECT_E_SET_KEY(thr->heap, obj, desc.e_idx, NULL);
-+		DUK_HSTRING_DECREF(thr, key);
-+		goto success;
-+	}
-+
-+	DUK_UNREACHABLE();
-+
-+ success:
-+	/*
-+	 *  Argument exotic [[Delete]] behavior (E5 Section 10.6) is
-+	 *  a post-check, keeping arguments internal 'map' in sync with
-+	 *  any successful deletes (note that property does not need to
-+	 *  exist for delete to 'succeed').
-+	 *
-+	 *  Delete key from 'map'.  Since 'map' only contains array index
-+	 *  keys, we can use arr_idx for a fast skip.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("delete successful, check for arguments exotic behavior"));
-+
-+	if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) {
-+		/* Note: only numbered indices are relevant, so arr_idx fast reject
-+		 * is good (this is valid unless there are more than 4**32-1 arguments).
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("delete successful, arguments exotic behavior needed"));
-+
-+		/* Note: we can reuse 'desc' here */
-+		(void) duk__check_arguments_map_for_delete(thr, obj, key, &desc);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("delete successful"));
-+	return 1;
-+
-+ fail_virtual:
-+	DUK_DDD(DUK_DDDPRINT("delete failed: property found, force flag, but virtual"));
-+
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROPERTY_IS_VIRTUAL);
-+	}
-+	return 0;
-+
-+ fail_not_configurable:
-+	DUK_DDD(DUK_DDDPRINT("delete failed: property found, not configurable"));
-+
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONFIGURABLE);
-+	}
-+	return 0;
-+}
-+
-+/*
-+ *  DELPROP: Ecmascript property deletion.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_delprop(duk_hthread *thr, duk_tval *tv_obj, duk_tval *tv_key, duk_bool_t throw_flag) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *key = NULL;
-+#if defined(DUK_USE_ES6_PROXY)
-+	duk_propdesc desc;
-+#endif
-+	duk_int_t entry_top;
-+	duk_uint32_t arr_idx = DUK__NO_ARRAY_INDEX;
-+	duk_bool_t rc;
-+
-+	DUK_DDD(DUK_DDDPRINT("delprop: thr=%p, obj=%p, key=%p (obj -> %!T, key -> %!T)",
-+	                     (void *) thr, (void *) tv_obj, (void *) tv_key,
-+	                     (duk_tval *) tv_obj, (duk_tval *) tv_key));
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(tv_obj != NULL);
-+	DUK_ASSERT(tv_key != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/* Storing the entry top is cheaper here to ensure stack is correct at exit,
-+	 * as there are several paths out.
-+	 */
-+	entry_top = duk_get_top(ctx);
-+
-+	if (DUK_TVAL_IS_UNDEFINED(tv_obj) ||
-+	    DUK_TVAL_IS_NULL(tv_obj)) {
-+		DUK_DDD(DUK_DDDPRINT("base object is undefined or null -> reject"));
-+		goto fail_invalid_base_uncond;
-+	}
-+
-+	duk_push_tval(ctx, tv_obj);
-+	duk_push_tval(ctx, tv_key);
-+
-+	tv_obj = duk_get_tval(ctx, -2);
-+	if (DUK_TVAL_IS_OBJECT(tv_obj)) {
-+		duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_obj);
-+		DUK_ASSERT(obj != NULL);
-+
-+#if defined(DUK_USE_ES6_PROXY)
-+		if (DUK_UNLIKELY(DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(obj))) {
-+			duk_hobject *h_target;
-+			duk_bool_t tmp_bool;
-+
-+			/* Note: proxy handling must happen before key is string coerced. */
-+
-+			if (duk__proxy_check_prop(thr, obj, DUK_STRIDX_DELETE_PROPERTY, tv_key, &h_target)) {
-+				/* -> [ ... trap handler ] */
-+				DUK_DDD(DUK_DDDPRINT("-> proxy object 'deleteProperty' for key %!T", (duk_tval *) tv_key));
-+				duk_push_hobject(ctx, h_target);  /* target */
-+				duk_push_tval(ctx, tv_key);       /* P */
-+				duk_call_method(ctx, 2 /*nargs*/);
-+				tmp_bool = duk_to_boolean(ctx, -1);
-+				duk_pop(ctx);
-+				if (!tmp_bool) {
-+					goto fail_proxy_rejected;  /* retval indicates delete failed */
-+				}
-+
-+				/* Target object must be checked for a conflicting
-+				 * non-configurable property.
-+				 */
-+				arr_idx = duk__push_tval_to_hstring_arr_idx(ctx, tv_key, &key);
-+				DUK_ASSERT(key != NULL);
-+
-+				if (duk__get_own_property_desc_raw(thr, h_target, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
-+					int desc_reject;
-+
-+					DUK_DDD(DUK_DDDPRINT("proxy 'deleteProperty': target has matching property %!O, check for "
-+					                     "conflicting property; desc.flags=0x%08lx, "
-+					                     "desc.get=%p, desc.set=%p",
-+					                     (duk_heaphdr *) key, (unsigned long) desc.flags,
-+					                     (void *) desc.get, (void *) desc.set));
-+
-+					desc_reject = !(desc.flags & DUK_PROPDESC_FLAG_CONFIGURABLE);
-+					if (desc_reject) {
-+						/* unconditional */
-+						DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED);
-+					}
-+				}
-+				rc = 1;  /* success */
-+				goto done_rc;
-+			}
-+
-+			obj = h_target;  /* resume delete to target */
-+		}
-+#endif  /* DUK_USE_ES6_PROXY */
-+
-+		duk_to_string(ctx, -1);
-+		key = duk_get_hstring(ctx, -1);
-+		DUK_ASSERT(key != NULL);
-+
-+		rc = duk_hobject_delprop_raw(thr, obj, key, throw_flag ? DUK_DELPROP_FLAG_THROW : 0);
-+		goto done_rc;
-+	} else if (DUK_TVAL_IS_STRING(tv_obj)) {
-+		/* XXX: unnecessary string coercion for array indices,
-+		 * intentional to keep small.
-+		 */
-+		duk_hstring *h = DUK_TVAL_GET_STRING(tv_obj);
-+		DUK_ASSERT(h != NULL);
-+
-+		duk_to_string(ctx, -1);
-+		key = duk_get_hstring(ctx, -1);
-+		DUK_ASSERT(key != NULL);
-+
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			goto fail_not_configurable;
-+		}
-+
-+		arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
-+
-+		if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+		    arr_idx < DUK_HSTRING_GET_CHARLEN(h)) {
-+			goto fail_not_configurable;
-+		}
-+	} else if (DUK_TVAL_IS_BUFFER(tv_obj)) {
-+		/* XXX: unnecessary string coercion for array indices,
-+		 * intentional to keep small; some overlap with string
-+		 * handling.
-+		 */
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv_obj);
-+		DUK_ASSERT(h != NULL);
-+
-+		duk_to_string(ctx, -1);
-+		key = duk_get_hstring(ctx, -1);
-+		DUK_ASSERT(key != NULL);
-+
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+			goto fail_not_configurable;
-+		}
-+
-+		arr_idx = DUK_HSTRING_GET_ARRIDX_FAST(key);
-+
-+		if (arr_idx != DUK__NO_ARRAY_INDEX &&
-+		    arr_idx < DUK_HBUFFER_GET_SIZE(h)) {
-+			goto fail_not_configurable;
-+		}
-+	} else if (DUK_TVAL_IS_LIGHTFUNC(tv_obj)) {
-+		/* Lightfunc virtual properties are non-configurable, so
-+		 * reject if match any of them.
-+		 */
-+
-+		duk_to_string(ctx, -1);
-+		key = duk_get_hstring(ctx, -1);
-+		DUK_ASSERT(key != NULL);
-+
-+		if (duk__key_is_lightfunc_ownprop(thr, key)) {
-+			goto fail_not_configurable;
-+		}
-+	}
-+
-+	/* non-object base, no offending virtual property */
-+	rc = 1;
-+	goto done_rc;
-+
-+ done_rc:
-+	duk_set_top(ctx, entry_top);
-+	return rc;
-+
-+ fail_invalid_base_uncond:
-+	/* Note: unconditional throw */
-+	DUK_ASSERT(duk_get_top(ctx) == entry_top);
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_BASE);
-+	return 0;
-+
-+ fail_proxy_rejected:
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROXY_REJECTED);
-+	}
-+	duk_set_top(ctx, entry_top);
-+	return 0;
-+
-+ fail_not_configurable:
-+	if (throw_flag) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONFIGURABLE);
-+	}
-+	duk_set_top(ctx, entry_top);
-+	return 0;
-+}
-+
-+/*
-+ *  Internal helper to define a property with specific flags, ignoring
-+ *  normal semantics such as extensibility, write protection etc.
-+ *  Overwrites any existing value and attributes unless caller requests
-+ *  that value only be updated if it doesn't already exists.
-+ *
-+ *  Does not support:
-+ *    - virtual properties (error if write attempted)
-+ *    - getter/setter properties (error if write attempted)
-+ *    - non-default (!= WEC) attributes for array entries (error if attempted)
-+ *    - array abandoning: if array part exists, it is always extended
-+ *    - array 'length' updating
-+ *
-+ *  Stack: [... in_val] -> []
-+ *
-+ *  Used for e.g. built-in initialization and environment record
-+ *  operations.
-+ */
-+
-+DUK_INTERNAL void duk_hobject_define_property_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_small_uint_t flags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_propdesc desc;
-+	duk_uint32_t arr_idx;
-+	duk_int_t e_idx;
-+	duk_tval tv_tmp;
-+	duk_tval *tv1 = NULL;
-+	duk_tval *tv2 = NULL;
-+	duk_small_uint_t propflags = flags & DUK_PROPDESC_FLAGS_MASK;  /* mask out flags not actually stored */
-+
-+	DUK_DDD(DUK_DDDPRINT("define new property (internal): thr=%p, obj=%!O, key=%!O, flags=0x%02lx, val=%!T",
-+	                     (void *) thr, (duk_heaphdr *) obj, (duk_heaphdr *) key,
-+	                     (unsigned long) flags, (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+	DUK_ASSERT(duk_is_valid_index(ctx, -1));  /* contains value */
-+
-+	arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
-+
-+	if (duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &desc, 0 /*flags*/)) {  /* don't push value */
-+		if (desc.e_idx >= 0) {
-+			if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
-+				DUK_DDD(DUK_DDDPRINT("property already exists in the entry part -> skip as requested"));
-+				goto pop_exit;
-+			}
-+			DUK_DDD(DUK_DDDPRINT("property already exists in the entry part -> update value and attributes"));
-+			if (DUK_UNLIKELY(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, desc.e_idx))) {
-+				DUK_D(DUK_DPRINT("existing property is an accessor, not supported"));
-+				goto error_internal;
-+			}
-+
-+			DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, desc.e_idx, propflags);
-+			tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, desc.e_idx);
-+		} else if (desc.a_idx >= 0) {
-+			if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
-+				DUK_DDD(DUK_DDDPRINT("property already exists in the array part -> skip as requested"));
-+				goto pop_exit;
-+			}
-+			DUK_DDD(DUK_DDDPRINT("property already exists in the array part -> update value (assert attributes)"));
-+			if (propflags != DUK_PROPDESC_FLAGS_WEC) {
-+				DUK_D(DUK_DPRINT("existing property in array part, but propflags not WEC (0x%02lx)",
-+				                 (unsigned long) propflags));
-+				goto error_internal;
-+			}
-+
-+			tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, desc.a_idx);
-+		} else {
-+			if (flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) {
-+				DUK_DDD(DUK_DDDPRINT("property already exists but is virtual -> skip as requested"));
-+				goto pop_exit;
-+			}
-+			DUK_DDD(DUK_DDDPRINT("property already exists but is virtual -> failure"));
-+			goto error_virtual;
-+		}
-+
-+		goto write_value;
-+	}
-+
-+	if (DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
-+		if (arr_idx != DUK__NO_ARRAY_INDEX) {
-+			DUK_DDD(DUK_DDDPRINT("property does not exist, object has array part -> possibly extend array part and write value (assert attributes)"));
-+			DUK_ASSERT(propflags == DUK_PROPDESC_FLAGS_WEC);
-+
-+			/* always grow the array, no sparse / abandon support here */
-+			if (arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)) {
-+				duk__grow_props_for_array_item(thr, obj, arr_idx);
-+			}
-+
-+			DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(obj));
-+			tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
-+			goto write_value;
-+		}
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("property does not exist, object belongs in entry part -> allocate new entry and write value and attributes"));
-+	e_idx = duk__alloc_entry_checked(thr, obj, key);  /* increases key refcount */
-+	DUK_ASSERT(e_idx >= 0);
-+	DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, propflags);
-+	tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
-+	/* new entry: previous value is garbage; set to undefined to share write_value */
-+	DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1);
-+	goto write_value;
-+
-+ write_value:
-+	/* tv1 points to value storage */
-+
-+	tv2 = duk_require_tval(ctx, -1);  /* late lookup, avoid side effects */
-+	DUK_DDD(DUK_DDDPRINT("writing/updating value: %!T -> %!T",
-+	                     (duk_tval *) tv1, (duk_tval *) tv2));
-+
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+	DUK_TVAL_SET_TVAL(tv1, tv2);
-+	DUK_TVAL_INCREF(thr, tv1);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+	goto pop_exit;
-+
-+ pop_exit:
-+	duk_pop(ctx);  /* remove in_val */
-+	return;
-+
-+ error_internal:
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR);
-+	return;
-+
-+ error_virtual:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_REDEFINE_VIRT_PROP);
-+	return;
-+}
-+
-+/*
-+ *  Fast path for defining array indexed values without interning the key.
-+ *  This is used by e.g. code for Array prototype and traceback creation so
-+ *  must avoid interning.
-+ */
-+
-+DUK_INTERNAL void duk_hobject_define_property_internal_arridx(duk_hthread *thr, duk_hobject *obj, duk_uarridx_t arr_idx, duk_small_uint_t flags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *key;
-+	duk_tval *tv1, *tv2;
-+	duk_tval tv_tmp;
-+
-+	DUK_DDD(DUK_DDDPRINT("define new property (internal) arr_idx fast path: thr=%p, obj=%!O, "
-+	                     "arr_idx=%ld, flags=0x%02lx, val=%!T",
-+	                     (void *) thr, obj, (long) arr_idx, (unsigned long) flags,
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+
-+	if (DUK_HOBJECT_HAS_ARRAY_PART(obj) &&
-+	    arr_idx != DUK__NO_ARRAY_INDEX &&
-+	    flags == DUK_PROPDESC_FLAGS_WEC) {
-+		DUK_ASSERT((flags & DUK_PROPDESC_FLAG_NO_OVERWRITE) == 0);  /* covered by comparison */
-+
-+		DUK_DDD(DUK_DDDPRINT("define property to array part (property may or may not exist yet)"));
-+
-+		/* always grow the array, no sparse / abandon support here */
-+		if (arr_idx >= DUK_HOBJECT_GET_ASIZE(obj)) {
-+			duk__grow_props_for_array_item(thr, obj, arr_idx);
-+		}
-+
-+		DUK_ASSERT(arr_idx < DUK_HOBJECT_GET_ASIZE(obj));
-+		tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, arr_idx);
-+		tv2 = duk_require_tval(ctx, -1);
-+
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+		DUK_TVAL_SET_TVAL(tv1, tv2);
-+		DUK_TVAL_INCREF(thr, tv1);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+		duk_pop(ctx);  /* [ ...val ] -> [ ... ] */
-+		return;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("define property fast path didn't work, use slow path"));
-+
-+	duk_push_uint(ctx, (duk_uint_t) arr_idx);
-+	key = duk_to_hstring(ctx, -1);
-+	DUK_ASSERT(key != NULL);
-+	duk_insert(ctx, -2);  /* [ ... val key ] -> [ ... key val ] */
-+
-+	duk_hobject_define_property_internal(thr, obj, key, flags);
-+
-+	duk_pop(ctx);  /* [ ... key ] -> [ ... ] */
-+}
-+
-+/*
-+ *  Internal helper for defining an accessor property, ignoring
-+ *  normal semantics such as extensibility, write protection etc.
-+ *  Overwrites any existing value and attributes.  This is called
-+ *  very rarely, so the implementation first sets a value to undefined
-+ *  and then changes the entry to an accessor (this is to save code space).
-+ */
-+
-+DUK_INTERNAL void duk_hobject_define_accessor_internal(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_hobject *getter, duk_hobject *setter, duk_small_uint_t propflags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_int_t e_idx;
-+	duk_int_t h_idx;
-+
-+	DUK_DDD(DUK_DDDPRINT("define new accessor (internal): thr=%p, obj=%!O, key=%!O, "
-+	                     "getter=%!O, setter=%!O, flags=0x%02lx",
-+	                     (void *) thr, (duk_heaphdr *) obj, (duk_heaphdr *) key,
-+	                     (duk_heaphdr *) getter, (duk_heaphdr *) setter,
-+	                     (unsigned long) propflags));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	DUK_ASSERT((propflags & ~DUK_PROPDESC_FLAGS_MASK) == 0);
-+	/* setter and/or getter may be NULL */
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/* force the property to 'undefined' to create a slot for it */
-+	duk_push_undefined(ctx);
-+	duk_hobject_define_property_internal(thr, obj, key, propflags);
-+	duk_hobject_find_existing_entry(thr->heap, obj, key, &e_idx, &h_idx);
-+	DUK_DDD(DUK_DDDPRINT("accessor slot: e_idx=%ld, h_idx=%ld", (long) e_idx, (long) h_idx));
-+	DUK_ASSERT(e_idx >= 0);
-+	DUK_ASSERT((duk_uint32_t) e_idx < DUK_HOBJECT_GET_ENEXT(obj));
-+
-+	/* no need to decref, as previous value is 'undefined' */
-+	DUK_HOBJECT_E_SLOT_SET_ACCESSOR(thr->heap, obj, e_idx);
-+	DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, e_idx, getter);
-+	DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, e_idx, setter);
-+	DUK_HOBJECT_INCREF_ALLOWNULL(thr, getter);
-+	DUK_HOBJECT_INCREF_ALLOWNULL(thr, setter);
-+}
-+
-+/*
-+ *  Internal helpers for managing object 'length'
-+ */
-+
-+/* XXX: awkward helpers */
-+
-+DUK_INTERNAL void duk_hobject_set_length(duk_hthread *thr, duk_hobject *obj, duk_uint32_t length) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_push_hobject(ctx, obj);
-+	duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
-+	duk_push_u32(ctx, length);
-+	(void) duk_hobject_putprop(thr, duk_get_tval(ctx, -3), duk_get_tval(ctx, -2), duk_get_tval(ctx, -1), 0);
-+	duk_pop_n(ctx, 3);
-+}
-+
-+DUK_INTERNAL void duk_hobject_set_length_zero(duk_hthread *thr, duk_hobject *obj) {
-+	duk_hobject_set_length(thr, obj, 0);
-+}
-+
-+DUK_INTERNAL duk_uint32_t duk_hobject_get_length(duk_hthread *thr, duk_hobject *obj) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_double_t val;
-+	duk_push_hobject(ctx, obj);
-+	duk_push_hstring_stridx(ctx, DUK_STRIDX_LENGTH);
-+	(void) duk_hobject_getprop(thr, duk_get_tval(ctx, -2), duk_get_tval(ctx, -1));
-+	val = duk_to_number(ctx, -1);
-+	duk_pop_n(ctx, 3);
-+	if (val >= 0.0 && val < DUK_DOUBLE_2TO32) {
-+		return (duk_uint32_t) val;
-+	}
-+	return 0;
-+}
-+
-+/*
-+ *  Object.getOwnPropertyDescriptor()  (E5 Sections 15.2.3.3, 8.10.4)
-+ *
-+ *  This is an actual function call.
-+ */
-+
-+DUK_INTERNAL duk_ret_t duk_hobject_object_get_own_property_descriptor(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hobject *obj;
-+	duk_hstring *key;
-+	duk_propdesc pd;
-+	duk_bool_t rc;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+
-+	obj = duk_require_hobject_or_lfunc_coerce(ctx, 0);
-+	(void) duk_to_string(ctx, 1);
-+	key = duk_require_hstring(ctx, 1);
-+
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	rc = duk__get_own_property_desc(thr, obj, key, &pd, DUK__DESC_FLAG_PUSH_VALUE);
-+	if (!rc) {
-+		duk_push_undefined(ctx);
-+
-+		/* [obj key undefined] */
-+		return 1;
-+	}
-+
-+	duk_push_object(ctx);
-+
-+	/* [obj key value desc] */
-+
-+	if (DUK_PROPDESC_IS_ACCESSOR(&pd)) {
-+		/* If a setter/getter is missing (undefined), the descriptor must
-+		 * still have the property present with the value 'undefined'.
-+		 */
-+		if (pd.get) {
-+			duk_push_hobject(ctx, pd.get);
-+		} else {
-+			duk_push_undefined(ctx);
-+		}
-+		duk_put_prop_stridx(ctx, -2, DUK_STRIDX_GET);
-+		if (pd.set) {
-+			duk_push_hobject(ctx, pd.set);
-+		} else {
-+			duk_push_undefined(ctx);
-+		}
-+		duk_put_prop_stridx(ctx, -2, DUK_STRIDX_SET);
-+	} else {
-+		duk_dup(ctx, -2);  /* [obj key value desc value] */
-+		duk_put_prop_stridx(ctx, -2, DUK_STRIDX_VALUE);
-+		duk_push_boolean(ctx, DUK_PROPDESC_IS_WRITABLE(&pd));
-+		duk_put_prop_stridx(ctx, -2, DUK_STRIDX_WRITABLE);
-+
-+		/* [obj key value desc] */
-+	}
-+	duk_push_boolean(ctx, DUK_PROPDESC_IS_ENUMERABLE(&pd));
-+	duk_put_prop_stridx(ctx, -2, DUK_STRIDX_ENUMERABLE);
-+	duk_push_boolean(ctx, DUK_PROPDESC_IS_CONFIGURABLE(&pd));
-+	duk_put_prop_stridx(ctx, -2, DUK_STRIDX_CONFIGURABLE);
-+
-+	/* [obj key value desc] */
-+	return 1;
-+}
-+
-+/*
-+ *  NormalizePropertyDescriptor() related helper.
-+ *
-+ *  Internal helper which validates and normalizes a property descriptor
-+ *  represented as an Ecmascript object (e.g. argument to defineProperty()).
-+ *  The output of this conversion is a set of defprop_flags and possibly
-+ *  some values pushed on the value stack; some subset of: property value,
-+ *  getter, setter.  Caller must manage stack top carefully because the
-+ *  number of values pushed depends on the input property descriptor.
-+ *
-+ *  The original descriptor object must not be altered in the process.
-+ */
-+
-+/* XXX: very basic optimization -> duk_get_prop_stridx_top */
-+
-+DUK_INTERNAL
-+void duk_hobject_prepare_property_descriptor(duk_context *ctx,
-+                                             duk_idx_t idx_in,
-+                                             duk_uint_t *out_defprop_flags,
-+                                             duk_idx_t *out_idx_value,
-+                                             duk_hobject **out_getter,
-+                                             duk_hobject **out_setter) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_idx_t idx_value = -1;
-+	duk_hobject *getter = NULL;
-+	duk_hobject *setter = NULL;
-+	duk_bool_t is_data_desc = 0;
-+	duk_bool_t is_acc_desc = 0;
-+	duk_uint_t defprop_flags = 0;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(out_defprop_flags != NULL);
-+	DUK_ASSERT(out_idx_value != NULL);
-+	DUK_ASSERT(out_getter != NULL);
-+	DUK_ASSERT(out_setter != NULL);
-+
-+	/* Must be an object, otherwise TypeError (E5.1 Section 8.10.5, step 1). */
-+	idx_in = duk_require_normalize_index(ctx, idx_in);
-+	(void) duk_require_hobject(ctx, idx_in);
-+
-+	/* The coercion order must match the ToPropertyDescriptor() algorithm
-+	 * so that side effects in coercion happen in the correct order.
-+	 * (This order also happens to be compatible with duk_def_prop(),
-+	 * although it doesn't matter in practice.)
-+	 */
-+
-+	if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_VALUE)) {
-+		is_data_desc = 1;
-+		defprop_flags |= DUK_DEFPROP_HAVE_VALUE;
-+		idx_value = duk_get_top_index(ctx);
-+		/* Leave 'value' on stack */
-+	} else {
-+		duk_pop(ctx);
-+	}
-+
-+	if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_WRITABLE)) {
-+		is_data_desc = 1;
-+		if (duk_to_boolean(ctx, -1)) {
-+			defprop_flags |= DUK_DEFPROP_HAVE_WRITABLE | DUK_DEFPROP_WRITABLE;
-+		} else {
-+			defprop_flags |= DUK_DEFPROP_HAVE_WRITABLE;
-+		}
-+	}
-+	duk_pop(ctx);
-+
-+	if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_GET)) {
-+		duk_tval *tv = duk_require_tval(ctx, -1);
-+		duk_hobject *h_get;
-+
-+		if (DUK_TVAL_IS_UNDEFINED(tv)) {
-+			/* undefined is accepted */
-+			DUK_ASSERT(getter == NULL);
-+		} else {
-+			/* NOTE: lightfuncs are coerced to full functions because
-+			 * lightfuncs don't fit into a property value slot.  This
-+			 * has some side effects, see test-dev-lightfunc-accessor.js.
-+			 */
-+			h_get = duk_get_hobject_or_lfunc_coerce(ctx, -1);
-+			if (h_get == NULL || !DUK_HOBJECT_IS_CALLABLE(h_get)) {
-+				goto type_error;
-+			}
-+			getter = h_get;
-+		}
-+		is_acc_desc = 1;
-+		defprop_flags |= DUK_DEFPROP_HAVE_GETTER;
-+		/* Leave 'getter' on stack */
-+	} else {
-+		duk_pop(ctx);
-+	}
-+
-+	if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_SET)) {
-+		duk_tval *tv = duk_require_tval(ctx, -1);
-+		duk_hobject *h_set;
-+
-+		is_acc_desc = 1;
-+		if (DUK_TVAL_IS_UNDEFINED(tv)) {
-+			/* undefined is accepted */
-+			DUK_ASSERT(setter == NULL);
-+		}  else {
-+			/* NOTE: lightfuncs are coerced to full functions because
-+			 * lightfuncs don't fit into a property value slot.  This
-+			 * has some side effects, see test-dev-lightfunc-accessor.js.
-+			 */
-+			h_set = duk_get_hobject_or_lfunc_coerce(ctx, -1);
-+			if (h_set == NULL || !DUK_HOBJECT_IS_CALLABLE(h_set)) {
-+				goto type_error;
-+			}
-+			setter = h_set;
-+		}
-+		is_acc_desc = 1;
-+		defprop_flags |= DUK_DEFPROP_HAVE_SETTER;
-+		/* Leave 'setter' on stack */
-+	} else {
-+		duk_pop(ctx);
-+	}
-+
-+	if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_ENUMERABLE)) {
-+		if (duk_to_boolean(ctx, -1)) {
-+			defprop_flags |= DUK_DEFPROP_HAVE_ENUMERABLE | DUK_DEFPROP_ENUMERABLE;
-+		} else {
-+			defprop_flags |= DUK_DEFPROP_HAVE_ENUMERABLE;
-+		}
-+	}
-+	duk_pop(ctx);
-+
-+	if (duk_get_prop_stridx(ctx, idx_in, DUK_STRIDX_CONFIGURABLE)) {
-+		if (duk_to_boolean(ctx, -1)) {
-+			defprop_flags |= DUK_DEFPROP_HAVE_CONFIGURABLE | DUK_DEFPROP_CONFIGURABLE;
-+		} else {
-+			defprop_flags |= DUK_DEFPROP_HAVE_CONFIGURABLE;
-+		}
-+	}
-+	duk_pop(ctx);
-+
-+	if (is_data_desc && is_acc_desc) {
-+		goto type_error;
-+	}
-+
-+	*out_defprop_flags = defprop_flags;
-+	*out_idx_value = idx_value;
-+	*out_getter = getter;
-+	*out_setter = setter;
-+
-+	/* [ ... value? getter? setter? ] */
-+	return;
-+
-+ type_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_INVALID_DESCRIPTOR);
-+}
-+
-+/*
-+ *  Object.defineProperty() related helper  (E5 Section 15.2.3.6)
-+ *
-+ *  Inlines all [[DefineOwnProperty]] exotic behaviors.
-+ *
-+ *  Note: Ecmascript compliant [[DefineOwnProperty]](P, Desc, Throw) is not
-+ *  implemented directly, but Object.defineProperty() serves its purpose.
-+ *  We don't need the [[DefineOwnProperty]] internally and we don't have a
-+ *  property descriptor with 'missing values' so it's easier to avoid it
-+ *  entirely.
-+ *
-+ *  Note: this is only called for actual objects, not primitive values.
-+ *  This must support virtual properties for full objects (e.g. Strings)
-+ *  but not for plain values (e.g. strings).  Lightfuncs, even though
-+ *  primitive in a sense, are treated like objects and accepted as target
-+ *  values.
-+ */
-+
-+/* XXX: this is a major target for size optimization */
-+DUK_INTERNAL
-+void duk_hobject_define_property_helper(duk_context *ctx,
-+                                        duk_uint_t defprop_flags,
-+                                        duk_hobject *obj,
-+                                        duk_hstring *key,
-+                                        duk_idx_t idx_value,
-+                                        duk_hobject *get,
-+                                        duk_hobject *set) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_uint32_t arr_idx;
-+	duk_tval tv;
-+	duk_bool_t has_enumerable;
-+	duk_bool_t has_configurable;
-+	duk_bool_t has_writable;
-+	duk_bool_t has_value;
-+	duk_bool_t has_get;
-+	duk_bool_t has_set;
-+	duk_bool_t is_enumerable;
-+	duk_bool_t is_configurable;
-+	duk_bool_t is_writable;
-+	duk_bool_t throw_flag;
-+	duk_bool_t force_flag;
-+	duk_small_uint_t new_flags;
-+	duk_propdesc curr;
-+	duk_uint32_t arridx_new_array_length;  /* != 0 => post-update for array 'length' (used when key is an array index) */
-+	duk_uint32_t arrlen_old_len;
-+	duk_uint32_t arrlen_new_len;
-+	duk_bool_t pending_write_protect;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(obj != NULL);
-+	DUK_ASSERT(key != NULL);
-+	/* idx_value may be < 0 (no value), set and get may be NULL */
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/* All the flags fit in 16 bits, so will fit into duk_bool_t. */
-+
-+	has_writable = (defprop_flags & DUK_DEFPROP_HAVE_WRITABLE);
-+	has_enumerable = (defprop_flags & DUK_DEFPROP_HAVE_ENUMERABLE);
-+	has_configurable = (defprop_flags & DUK_DEFPROP_HAVE_CONFIGURABLE);
-+	has_value = (defprop_flags & DUK_DEFPROP_HAVE_VALUE);
-+	has_get = (defprop_flags & DUK_DEFPROP_HAVE_GETTER);
-+	has_set = (defprop_flags & DUK_DEFPROP_HAVE_SETTER);
-+	is_writable = (defprop_flags & DUK_DEFPROP_WRITABLE);
-+	is_enumerable = (defprop_flags & DUK_DEFPROP_ENUMERABLE);
-+	is_configurable = (defprop_flags & DUK_DEFPROP_CONFIGURABLE);
-+	throw_flag = 1;   /* Object.defineProperty() calls [[DefineOwnProperty]] with Throw=true */
-+	force_flag = (defprop_flags & DUK_DEFPROP_FORCE);
-+
-+	arr_idx = DUK_HSTRING_GET_ARRIDX_SLOW(key);
-+
-+	arridx_new_array_length = 0;
-+	pending_write_protect = 0;
-+	arrlen_old_len = 0;
-+	arrlen_new_len = 0;
-+
-+	DUK_DDD(DUK_DDDPRINT("has_enumerable=%ld is_enumerable=%ld "
-+	                     "has_configurable=%ld is_configurable=%ld "
-+	                     "has_writable=%ld is_writable=%ld "
-+	                     "has_value=%ld value=%!T "
-+	                     "has_get=%ld get=%p=%!O "
-+	                     "has_set=%ld set=%p=%!O "
-+	                     "arr_idx=%ld",
-+	                     (long) has_enumerable, (long) is_enumerable,
-+	                     (long) has_configurable, (long) is_configurable,
-+	                     (long) has_writable, (long) is_writable,
-+	                     (long) has_value, (duk_tval *) (idx_value >= 0 ? duk_get_tval(ctx, idx_value) : NULL),
-+	                     (long) has_get, (void *) get, (duk_heaphdr *) get,
-+	                     (long) has_set, (void *) set, (duk_heaphdr *) set,
-+	                     (long) arr_idx));
-+
-+	/*
-+	 *  Array exotic behaviors can be implemented at this point.  The local variables
-+	 *  are essentially a 'value copy' of the input descriptor (Desc), which is modified
-+	 *  by the Array [[DefineOwnProperty]] (E5 Section 15.4.5.1).
-+	 */
-+
-+	if (!DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)) {
-+		goto skip_array_exotic;
-+	}
-+
-+	if (key == DUK_HTHREAD_STRING_LENGTH(thr)) {
-+		/* E5 Section 15.4.5.1, step 3, steps a - i are implemented here, j - n at the end */
-+		if (!has_value) {
-+			DUK_DDD(DUK_DDDPRINT("exotic array behavior for 'length', but no value in descriptor -> normal behavior"));
-+			goto skip_array_exotic;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("exotic array behavior for 'length', value present in descriptor -> exotic behavior"));
-+
-+		/*
-+		 *  Get old and new length
-+		 */
-+
-+		/* Note: reuse 'curr' as a temp propdesc */
-+		arrlen_old_len = duk__get_old_array_length(thr, obj, &curr);
-+
-+		duk_dup(ctx, idx_value);
-+		arrlen_new_len = duk__to_new_array_length_checked(thr);
-+		duk_push_u32(ctx, arrlen_new_len);
-+		duk_replace(ctx, idx_value);  /* step 3.e: replace 'Desc.[[Value]]' */
-+
-+		DUK_DDD(DUK_DDDPRINT("old_len=%ld, new_len=%ld", (long) arrlen_old_len, (long) arrlen_new_len));
-+
-+		if (arrlen_new_len >= arrlen_old_len) {
-+			/* standard behavior, step 3.f.i */
-+			DUK_DDD(DUK_DDDPRINT("new length is same or higher as previous => standard behavior"));
-+			goto skip_array_exotic;
-+		}
-+		DUK_DDD(DUK_DDDPRINT("new length is smaller than previous => exotic post behavior"));
-+
-+		/* XXX: consolidated algorithm step 15.f -> redundant? */
-+		if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && !force_flag) {
-+			/* Note: 'curr' refers to 'length' propdesc */
-+			goto fail_not_writable_array_length;
-+		}
-+
-+		/* steps 3.h and 3.i */
-+		if (has_writable && !is_writable) {
-+			DUK_DDD(DUK_DDDPRINT("desc writable is false, force it back to true, and flag pending write protect"));
-+			is_writable = 1;
-+			pending_write_protect = 1;
-+		}
-+
-+		/* remaining actual steps are carried out if standard DefineOwnProperty succeeds */
-+	} else if (arr_idx != DUK__NO_ARRAY_INDEX) {
-+		/* XXX: any chance of unifying this with the 'length' key handling? */
-+
-+		/* E5 Section 15.4.5.1, step 4 */
-+		duk_uint32_t old_len;
-+
-+		/* Note: use 'curr' as a temp propdesc */
-+		old_len = duk__get_old_array_length(thr, obj, &curr);
-+
-+		if (arr_idx >= old_len) {
-+			DUK_DDD(DUK_DDDPRINT("defineProperty requires array length update "
-+			                     "(arr_idx=%ld, old_len=%ld)",
-+			                     (long) arr_idx, (long) old_len));
-+
-+			if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
-+				/* Note: 'curr' refers to 'length' propdesc */
-+				goto fail_not_writable_array_length;
-+			}
-+
-+			/* actual update happens once write has been completed without
-+			 * error below.
-+			 */
-+			DUK_ASSERT(arr_idx != 0xffffffffUL);
-+			arridx_new_array_length = arr_idx + 1;
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("defineProperty does not require length update "
-+			                     "(arr_idx=%ld, old_len=%ld) -> standard behavior",
-+			                     (long) arr_idx, (long) old_len));
-+		}
-+	}
-+ skip_array_exotic:
-+
-+	/* XXX: There is currently no support for writing buffer object
-+	 * indexed elements here.  Attempt to do so will succeed and
-+	 * write a concrete property into the buffer object.  This should
-+	 * be fixed at some point but because buffers are a custom feature
-+	 * anyway, this is relatively unimportant.
-+	 */
-+
-+	/*
-+	 *  Actual Object.defineProperty() default algorithm.
-+	 */
-+
-+	/*
-+	 *  First check whether property exists; if not, simple case.  This covers
-+	 *  steps 1-4.
-+	 */
-+
-+	if (!duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE)) {
-+		DUK_DDD(DUK_DDDPRINT("property does not exist"));
-+
-+		if (!DUK_HOBJECT_HAS_EXTENSIBLE(obj) && !force_flag) {
-+			goto fail_not_extensible;
-+		}
-+
-+		/* XXX: share final setting code for value and flags?  difficult because
-+		 * refcount code is different.  Share entry allocation?  But can't allocate
-+		 * until array index checked.
-+		 */
-+
-+		/* steps 4.a and 4.b are tricky */
-+		if (has_set || has_get) {
-+			duk_int_t e_idx;
-+
-+			DUK_DDD(DUK_DDDPRINT("create new accessor property"));
-+
-+			DUK_ASSERT(has_set || set == NULL);
-+			DUK_ASSERT(has_get || get == NULL);
-+			DUK_ASSERT(!has_value);
-+			DUK_ASSERT(!has_writable);
-+
-+			new_flags = DUK_PROPDESC_FLAG_ACCESSOR;  /* defaults, E5 Section 8.6.1, Table 7 */
-+			if (has_enumerable && is_enumerable) {
-+				new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
-+			}
-+			if (has_configurable && is_configurable) {
-+				new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
-+			}
-+
-+			if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
-+				DUK_DDD(DUK_DDDPRINT("accessor cannot go to array part, abandon array"));
-+				duk__abandon_array_checked(thr, obj);
-+			}
-+
-+			/* write to entry part */
-+			e_idx = duk__alloc_entry_checked(thr, obj, key);
-+			DUK_ASSERT(e_idx >= 0);
-+
-+			DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, e_idx, get);
-+			DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, e_idx, set);
-+			DUK_HOBJECT_INCREF_ALLOWNULL(thr, get);
-+			DUK_HOBJECT_INCREF_ALLOWNULL(thr, set);
-+
-+			DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, new_flags);
-+			goto success_exotics;
-+		} else {
-+			duk_int_t e_idx;
-+			duk_tval *tv2;
-+
-+			DUK_DDD(DUK_DDDPRINT("create new data property"));
-+
-+			DUK_ASSERT(!has_set);
-+			DUK_ASSERT(!has_get);
-+
-+			new_flags = 0;  /* defaults, E5 Section 8.6.1, Table 7 */
-+			if (has_writable && is_writable) {
-+				new_flags |= DUK_PROPDESC_FLAG_WRITABLE;
-+			}
-+			if (has_enumerable && is_enumerable) {
-+				new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
-+			}
-+			if (has_configurable && is_configurable) {
-+				new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
-+			}
-+			if (has_value) {
-+				duk_tval *tv_tmp = duk_require_tval(ctx, idx_value);
-+				DUK_TVAL_SET_TVAL(&tv, tv_tmp);
-+			} else {
-+				DUK_TVAL_SET_UNDEFINED_ACTUAL(&tv);  /* default value */
-+			}
-+
-+			if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_ARRAY_PART(obj)) {
-+				if (new_flags == DUK_PROPDESC_FLAGS_WEC) {
-+#if 0
-+					DUK_DDD(DUK_DDDPRINT("new data property attributes match array defaults, attempt to write to array part"));
-+					/* may become sparse...*/
-+#endif
-+					/* XXX: handling for array part missing now; this doesn't affect
-+					 * compliance but causes array entry writes using defineProperty()
-+					 * to always abandon array part.
-+					 */
-+				}
-+				DUK_DDD(DUK_DDDPRINT("new data property cannot go to array part, abandon array"));
-+				duk__abandon_array_checked(thr, obj);
-+				/* fall through */
-+			}
-+
-+			/* write to entry part */
-+			e_idx = duk__alloc_entry_checked(thr, obj, key);
-+			DUK_ASSERT(e_idx >= 0);
-+			tv2 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, e_idx);
-+			DUK_TVAL_SET_TVAL(tv2, &tv);
-+			DUK_TVAL_INCREF(thr, tv2);
-+
-+			DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, e_idx, new_flags);
-+			goto success_exotics;
-+		}
-+		DUK_UNREACHABLE();
-+	}
-+
-+	/* we currently assume virtual properties are not configurable (as none of them are) */
-+	DUK_ASSERT((curr.e_idx >= 0 || curr.a_idx >= 0) || !(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE));
-+
-+	/* [obj key desc value get set curr_value] */
-+
-+	/*
-+	 *  Property already exists.  Steps 5-6 detect whether any changes need
-+	 *  to be made.
-+	 */
-+
-+	if (has_enumerable) {
-+		if (is_enumerable) {
-+			if (!(curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE)) {
-+				goto need_check;
-+			}
-+		} else {
-+			if (curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE) {
-+				goto need_check;
-+			}
-+		}
-+	}
-+	if (has_configurable) {
-+		if (is_configurable) {
-+			if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
-+				goto need_check;
-+			}
-+		} else {
-+			if (curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) {
-+				goto need_check;
-+			}
-+		}
-+	}
-+	if (has_value) {
-+		duk_tval *tmp1;
-+		duk_tval *tmp2;
-+
-+		/* attempt to change from accessor to data property */
-+		if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+			goto need_check;
-+		}
-+
-+		tmp1 = duk_require_tval(ctx, -1);         /* curr value */
-+		tmp2 = duk_require_tval(ctx, idx_value);  /* new value */
-+		if (!duk_js_samevalue(tmp1, tmp2)) {
-+			goto need_check;
-+		}
-+	}
-+	if (has_writable) {
-+		/* attempt to change from accessor to data property */
-+		if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+			goto need_check;
-+		}
-+
-+		if (is_writable) {
-+			if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE)) {
-+				goto need_check;
-+			}
-+		} else {
-+			if (curr.flags & DUK_PROPDESC_FLAG_WRITABLE) {
-+				goto need_check;
-+			}
-+		}
-+	}
-+	if (has_set) {
-+		if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+			if (set != curr.set) {
-+				goto need_check;
-+			}
-+		} else {
-+			goto need_check;
-+		}
-+	}
-+	if (has_get) {
-+		if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+			if (get != curr.get) {
-+				goto need_check;
-+			}
-+		} else {
-+			goto need_check;
-+		}
-+	}
-+
-+	/* property exists, either 'desc' is empty, or all values
-+	 * match (SameValue)
-+	 */
-+	goto success_no_exotics;
-+
-+ need_check:
-+
-+	/*
-+	 *  Some change(s) need to be made.  Steps 7-11.
-+	 */
-+
-+	/* shared checks for all descriptor types */
-+	if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
-+		if (has_configurable && is_configurable) {
-+			goto fail_not_configurable;
-+		}
-+		if (has_enumerable) {
-+			if (curr.flags & DUK_PROPDESC_FLAG_ENUMERABLE) {
-+				if (!is_enumerable) {
-+					goto fail_not_configurable;
-+				}
-+			} else {
-+				if (is_enumerable) {
-+					goto fail_not_configurable;
-+				}
-+			}
-+		}
-+	}
-+
-+	/* Reject attempt to change virtual properties: not part of the
-+	 * standard algorithm, applies currently to e.g. virtual index
-+	 * properties of buffer objects (which are virtual but writable).
-+	 * (Cannot "force" modification of a virtual property.)
-+	 */
-+	if (curr.flags & DUK_PROPDESC_FLAG_VIRTUAL) {
-+		goto fail_virtual;
-+	}
-+
-+	/* descriptor type specific checks */
-+	if (has_set || has_get) {
-+		/* IsAccessorDescriptor(desc) == true */
-+		DUK_ASSERT(!has_writable);
-+		DUK_ASSERT(!has_value);
-+
-+		if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+			/* curr and desc are accessors */
-+			if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
-+				if (has_set && set != curr.set) {
-+					goto fail_not_configurable;
-+				}
-+				if (has_get && get != curr.get) {
-+					goto fail_not_configurable;
-+				}
-+			}
-+		} else {
-+			duk_bool_t rc;
-+			duk_tval tv_tmp;
-+			duk_tval *tv1;
-+
-+			/* curr is data, desc is accessor */
-+			if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
-+				goto fail_not_configurable;
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("convert property to accessor property"));
-+			if (curr.a_idx >= 0) {
-+				DUK_DDD(DUK_DDDPRINT("property to convert is stored in an array entry, abandon array and re-lookup"));
-+				duk__abandon_array_checked(thr, obj);
-+				duk_pop(ctx);  /* remove old value */
-+				rc = duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE);
-+				DUK_UNREF(rc);
-+				DUK_ASSERT(rc != 0);
-+				DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
-+			}
-+
-+			DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
-+
-+			tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+			DUK_TVAL_SET_UNDEFINED_UNUSED(tv1);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+			DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL);
-+			DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL);
-+			DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
-+			DUK_HOBJECT_E_SLOT_SET_ACCESSOR(thr->heap, obj, curr.e_idx);
-+
-+			DUK_DDD(DUK_DDDPRINT("flags after data->accessor conversion: 0x%02lx",
-+			                     (unsigned long) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, curr.e_idx)));
-+
-+			/* re-lookup to update curr.flags
-+			 * XXX: would be faster to update directly
-+			 */
-+			duk_pop(ctx);  /* remove old value */
-+			rc = duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE);
-+			DUK_UNREF(rc);
-+			DUK_ASSERT(rc != 0);
-+		}
-+	} else if (has_value || has_writable) {
-+		/* IsDataDescriptor(desc) == true */
-+		DUK_ASSERT(!has_set);
-+		DUK_ASSERT(!has_get);
-+
-+		if (curr.flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+			duk_bool_t rc;
-+			duk_hobject *tmp;
-+
-+			/* curr is accessor, desc is data */
-+			if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
-+				goto fail_not_configurable;
-+			}
-+
-+			/* curr is accessor -> cannot be in array part */
-+			DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
-+
-+			DUK_DDD(DUK_DDDPRINT("convert property to data property"));
-+
-+			DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
-+			tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx);
-+			DUK_UNREF(tmp);
-+			DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, NULL);
-+			DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+			tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx);
-+			DUK_UNREF(tmp);
-+			DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, NULL);
-+			DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+
-+			DUK_TVAL_SET_UNDEFINED_ACTUAL(DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx));
-+			DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
-+			DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(thr->heap, obj, curr.e_idx);
-+
-+			DUK_DDD(DUK_DDDPRINT("flags after accessor->data conversion: 0x%02lx",
-+			                     (unsigned long) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, curr.e_idx)));
-+
-+			/* re-lookup to update curr.flags
-+			 * XXX: would be faster to update directly
-+			 */
-+			duk_pop(ctx);  /* remove old value */
-+			rc = duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE);
-+			DUK_UNREF(rc);
-+			DUK_ASSERT(rc != 0);
-+		} else {
-+			/* curr and desc are data */
-+			if (!(curr.flags & DUK_PROPDESC_FLAG_CONFIGURABLE) && !force_flag) {
-+				if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && has_writable && is_writable) {
-+					goto fail_not_configurable;
-+				}
-+				/* Note: changing from writable to non-writable is OK */
-+				if (!(curr.flags & DUK_PROPDESC_FLAG_WRITABLE) && has_value) {
-+					duk_tval *tmp1 = duk_require_tval(ctx, -1);         /* curr value */
-+					duk_tval *tmp2 = duk_require_tval(ctx, idx_value);  /* new value */
-+					if (!duk_js_samevalue(tmp1, tmp2)) {
-+						goto fail_not_configurable;
-+					}
-+				}
-+			}
-+		}
-+	} else {
-+		/* IsGenericDescriptor(desc) == true; this means in practice that 'desc'
-+		 * only has [[Enumerable]] or [[Configurable]] flag updates, which are
-+		 * allowed at this point.
-+		 */
-+
-+		DUK_ASSERT(!has_value && !has_writable && !has_get && !has_set);
-+	}
-+
-+	/*
-+	 *  Start doing property attributes updates.  Steps 12-13.
-+	 *
-+	 *  Start by computing new attribute flags without writing yet.
-+	 *  Property type conversion is done above if necessary.
-+	 */
-+
-+	new_flags = curr.flags;
-+
-+	if (has_enumerable) {
-+		if (is_enumerable) {
-+			new_flags |= DUK_PROPDESC_FLAG_ENUMERABLE;
-+		} else {
-+			new_flags &= ~DUK_PROPDESC_FLAG_ENUMERABLE;
-+		}
-+	}
-+	if (has_configurable) {
-+		if (is_configurable) {
-+			new_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
-+		} else {
-+			new_flags &= ~DUK_PROPDESC_FLAG_CONFIGURABLE;
-+		}
-+	}
-+	if (has_writable) {
-+		if (is_writable) {
-+			new_flags |= DUK_PROPDESC_FLAG_WRITABLE;
-+		} else {
-+			new_flags &= ~DUK_PROPDESC_FLAG_WRITABLE;
-+		}
-+	}
-+
-+	/* XXX: write protect after flag? -> any chance of handling it here? */
-+
-+	DUK_DDD(DUK_DDDPRINT("new flags that we want to write: 0x%02lx",
-+	                     (unsigned long) new_flags));
-+
-+	/*
-+	 *  Check whether we need to abandon an array part (if it exists)
-+	 */
-+
-+	if (curr.a_idx >= 0) {
-+		duk_bool_t rc;
-+
-+		DUK_ASSERT(curr.e_idx < 0);
-+
-+		if (new_flags == DUK_PROPDESC_FLAGS_WEC) {
-+			duk_tval *tv1, *tv2;
-+			duk_tval tv_tmp;
-+
-+			DUK_DDD(DUK_DDDPRINT("array index, new property attributes match array defaults, update in-place"));
-+
-+			DUK_ASSERT(curr.flags == DUK_PROPDESC_FLAGS_WEC);  /* must have been, since in array part */
-+			DUK_ASSERT(!has_set);
-+			DUK_ASSERT(!has_get);
-+
-+			tv2 = duk_require_tval(ctx, idx_value);
-+			tv1 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, curr.a_idx);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+			DUK_TVAL_SET_TVAL(tv1, tv2);
-+			DUK_TVAL_INCREF(thr, tv1);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);
-+			goto success_exotics;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("array index, new property attributes do not match array defaults, abandon array and re-lookup"));
-+		duk__abandon_array_checked(thr, obj);
-+		duk_pop(ctx);  /* remove old value */
-+		rc = duk__get_own_property_desc_raw(thr, obj, key, arr_idx, &curr, DUK__DESC_FLAG_PUSH_VALUE);
-+		DUK_UNREF(rc);
-+		DUK_ASSERT(rc != 0);
-+		DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("updating existing property in entry part"));
-+
-+	/* array case is handled comprehensively above */
-+	DUK_ASSERT(curr.e_idx >= 0 && curr.a_idx < 0);
-+
-+	DUK_DDD(DUK_DDDPRINT("update existing property attributes"));
-+	DUK_HOBJECT_E_SET_FLAGS(thr->heap, obj, curr.e_idx, new_flags);
-+
-+	if (has_set) {
-+		duk_hobject *tmp;
-+
-+		DUK_DDD(DUK_DDDPRINT("update existing property setter"));
-+		DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
-+
-+		tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, obj, curr.e_idx);
-+		DUK_UNREF(tmp);
-+		DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, obj, curr.e_idx, set);
-+		DUK_HOBJECT_INCREF_ALLOWNULL(thr, set);
-+		DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+	}
-+	if (has_get) {
-+		duk_hobject *tmp;
-+
-+		DUK_DDD(DUK_DDDPRINT("update existing property getter"));
-+		DUK_ASSERT(DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
-+
-+		tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, obj, curr.e_idx);
-+		DUK_UNREF(tmp);
-+		DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, obj, curr.e_idx, get);
-+		DUK_HOBJECT_INCREF_ALLOWNULL(thr, get);
-+		DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+	}
-+	if (has_value) {
-+		duk_tval *tv1, *tv2;
-+		duk_tval tv_tmp;
-+
-+		DUK_DDD(DUK_DDDPRINT("update existing property value"));
-+		DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
-+
-+		tv2 = duk_require_tval(ctx, idx_value);
-+		tv1 = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+		DUK_TVAL_SET_TVAL(tv1, tv2);
-+		DUK_TVAL_INCREF(thr, tv1);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);
-+	}
-+
-+	/*
-+	 *  Standard algorithm succeeded without errors, check for exotic post-behaviors.
-+	 *
-+	 *  Arguments exotic behavior in E5 Section 10.6 occurs after the standard
-+	 *  [[DefineOwnProperty]] has completed successfully.
-+	 *
-+	 *  Array exotic behavior in E5 Section 15.4.5.1 is implemented partly
-+	 *  prior to the default [[DefineOwnProperty]], but:
-+	 *    - for an array index key (e.g. "10") the final 'length' update occurs here
-+	 *    - for 'length' key the element deletion and 'length' update occurs here
-+	 */
-+
-+ success_exotics:
-+
-+	/* [obj key desc value get set curr_value] */
-+
-+	if (DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj)) {
-+		if (arridx_new_array_length > 0) {
-+			duk_tval *tmp;
-+			duk_bool_t rc;
-+
-+			/*
-+			 *  Note: zero works as a "no update" marker because the new length
-+			 *  can never be zero after a new property is written.
-+			 */
-+
-+			/* E5 Section 15.4.5.1, steps 4.e.i - 4.e.ii */
-+
-+			DUK_DDD(DUK_DDDPRINT("defineProperty successful, pending array length update to: %ld",
-+			                     (long) arridx_new_array_length));
-+
-+			/* Note: reuse 'curr' */
-+			rc = duk__get_own_property_desc_raw(thr, obj, DUK_HTHREAD_STRING_LENGTH(thr), DUK__NO_ARRAY_INDEX, &curr, 0 /*flags*/);  /* don't push value */
-+			DUK_UNREF(rc);
-+			DUK_ASSERT(rc != 0);
-+			DUK_ASSERT(curr.e_idx >= 0);
-+
-+			tmp = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp));
-+			/* no need for decref/incref because value is a number */
-+#if defined(DUK_USE_FASTINT)
-+			DUK_TVAL_SET_FASTINT_U32(tmp, arridx_new_array_length);
-+#else
-+			DUK_TVAL_SET_NUMBER(tmp, (duk_double_t) arridx_new_array_length);
-+#endif
-+		}
-+		if (key == DUK_HTHREAD_STRING_LENGTH(thr) && arrlen_new_len < arrlen_old_len) {
-+			/*
-+			 *  E5 Section 15.4.5.1, steps 3.k - 3.n.  The order at the end combines
-+			 *  the error case 3.l.iii and the success case 3.m-3.n.
-+			 *
-+			 *  Note: 'length' is always in entries part, so no array abandon issues for
-+			 *  'writable' update.
-+			 */
-+
-+			/* XXX: investigate whether write protect can be handled above, if we
-+			 * just update length here while ignoring its protected status
-+			 */
-+
-+			duk_tval *tmp;
-+			duk_uint32_t result_len;
-+			duk_bool_t rc;
-+
-+			DUK_DDD(DUK_DDDPRINT("defineProperty successful, key is 'length', exotic array behavior, "
-+			                     "doing array element deletion and length update"));
-+
-+			rc = duk__handle_put_array_length_smaller(thr, obj, arrlen_old_len, arrlen_new_len, force_flag, &result_len);
-+
-+			/* update length (curr points to length, and we assume it's still valid) */
-+			DUK_ASSERT(result_len >= arrlen_new_len && result_len <= arrlen_old_len);
-+
-+			DUK_ASSERT(curr.e_idx >= 0);
-+			DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, obj, curr.e_idx));
-+			tmp = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, obj, curr.e_idx);
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp));
-+			/* no decref needed for a number */
-+#if defined(DUK_USE_FASTINT)
-+			DUK_TVAL_SET_FASTINT_U32(tmp, result_len);
-+#else
-+			DUK_TVAL_SET_NUMBER(tmp, (duk_double_t) result_len);
-+#endif
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tmp));
-+
-+			if (pending_write_protect) {
-+				DUK_DDD(DUK_DDDPRINT("setting array length non-writable (pending writability update)"));
-+				DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(thr->heap, obj, curr.e_idx);
-+			}
-+
-+			/*
-+			 *  XXX: shrink array allocation or entries compaction here?
-+			 */
-+
-+			if (!rc) {
-+				goto fail_array_length_partial;
-+			}
-+		}
-+	} else if (arr_idx != DUK__NO_ARRAY_INDEX && DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(obj)) {
-+		duk_hobject *map;
-+		duk_hobject *varenv;
-+
-+		DUK_ASSERT(arridx_new_array_length == 0);
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(obj));  /* traits are separate; in particular, arguments not an array */
-+
-+		map = NULL;
-+		varenv = NULL;
-+		if (!duk__lookup_arguments_map(thr, obj, key, &curr, &map, &varenv)) {
-+			goto success_no_exotics;
-+		}
-+		DUK_ASSERT(map != NULL);
-+		DUK_ASSERT(varenv != NULL);
-+
-+		/* [obj key desc value get set curr_value varname] */
-+
-+		if (has_set || has_get) {
-+			/* = IsAccessorDescriptor(Desc) */
-+			DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map' "
-+			                     "changed to an accessor, delete arguments binding"));
-+
-+			(void) duk_hobject_delprop_raw(thr, map, key, 0);  /* ignore result */
-+		} else {
-+			/* Note: this order matters (final value before deleting map entry must be done) */
-+			DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
-+			                     "check for value update / binding deletion"));
-+
-+			if (has_value) {
-+				duk_hstring *varname;
-+
-+				DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
-+				                     "update bound value (variable/argument)"));
-+
-+				varname = duk_require_hstring(ctx, -1);
-+				DUK_ASSERT(varname != NULL);
-+
-+				DUK_DDD(DUK_DDDPRINT("arguments object automatic putvar for a bound variable; "
-+				                     "key=%!O, varname=%!O, value=%!T",
-+				                     (duk_heaphdr *) key,
-+				                     (duk_heaphdr *) varname,
-+				                     (duk_tval *) duk_require_tval(ctx, idx_value)));
-+
-+				/* strict flag for putvar comes from our caller (currently: fixed) */
-+				duk_js_putvar_envrec(thr, varenv, varname, duk_require_tval(ctx, idx_value), throw_flag);
-+			}
-+			if (has_writable && !is_writable) {
-+				DUK_DDD(DUK_DDDPRINT("defineProperty successful, key mapped to arguments 'map', "
-+				                     "changed to non-writable, delete arguments binding"));
-+
-+				(void) duk_hobject_delprop_raw(thr, map, key, 0);  /* ignore result */
-+			}
-+		}
-+
-+		/* 'varname' is in stack in this else branch, leaving an unbalanced stack below,
-+		 * but this doesn't matter now.
-+		 */
-+	}
-+
-+ success_no_exotics:
-+	return;
-+
-+ fail_virtual:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_PROPERTY_IS_VIRTUAL);
-+	return;
-+
-+ fail_not_writable_array_length:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_ARRAY_LENGTH_NOT_WRITABLE);
-+	return;
-+
-+ fail_not_extensible:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_EXTENSIBLE);
-+	return;
-+
-+ fail_not_configurable:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CONFIGURABLE);
-+	return;
-+
-+ fail_array_length_partial:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_ARRAY_LENGTH_WRITE_FAILED);
-+	return;
-+}
-+
-+/*
-+ *  Object.prototype.hasOwnProperty() and Object.prototype.propertyIsEnumerable().
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_object_ownprop_helper(duk_context *ctx, duk_small_uint_t required_desc_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_v;
-+	duk_hobject *h_obj;
-+	duk_propdesc desc;
-+	duk_bool_t ret;
-+
-+	/* coercion order matters */
-+	h_v = duk_to_hstring(ctx, 0);
-+	DUK_ASSERT(h_v != NULL);
-+
-+	h_obj = duk_push_this_coercible_to_object(ctx);
-+	DUK_ASSERT(h_obj != NULL);
-+
-+	ret = duk__get_own_property_desc(thr, h_obj, h_v, &desc, 0 /*flags*/);  /* don't push value */
-+
-+	duk_push_boolean(ctx, ret && ((desc.flags & required_desc_flags) == required_desc_flags));
-+	return 1;
-+}
-+
-+/*
-+ *  Object.seal() and Object.freeze()  (E5 Sections 15.2.3.8 and 15.2.3.9)
-+ *
-+ *  Since the algorithms are similar, a helper provides both functions.
-+ *  Freezing is essentially sealing + making plain properties non-writable.
-+ *
-+ *  Note: virtual (non-concrete) properties which are non-configurable but
-+ *  writable would pose some problems, but such properties do not currently
-+ *  exist (all virtual properties are non-configurable and non-writable).
-+ *  If they did exist, the non-configurability does NOT prevent them from
-+ *  becoming non-writable.  However, this change should be recorded somehow
-+ *  so that it would turn up (e.g. when getting the property descriptor),
-+ *  requiring some additional flags in the object.
-+ */
-+
-+DUK_INTERNAL void duk_hobject_object_seal_freeze_helper(duk_hthread *thr, duk_hobject *obj, duk_bool_t is_freeze) {
-+	duk_uint_fast32_t i;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->heap != NULL);
-+	DUK_ASSERT(obj != NULL);
-+
-+	DUK_ASSERT_VALSTACK_SPACE(thr, DUK__VALSTACK_SPACE);
-+
-+	/*
-+	 *  Abandon array part because all properties must become non-configurable.
-+	 *  Note that this is now done regardless of whether this is always the case
-+	 *  (skips check, but performance problem if caller would do this many times
-+	 *  for the same object; not likely).
-+	 */
-+
-+	duk__abandon_array_checked(thr, obj);
-+	DUK_ASSERT(DUK_HOBJECT_GET_ASIZE(obj) == 0);
-+
-+	for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
-+		duk_uint8_t *fp;
-+
-+		/* since duk__abandon_array_checked() causes a resize, there should be no gaps in keys */
-+		DUK_ASSERT(DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i) != NULL);
-+
-+		/* avoid multiple computations of flags address; bypasses macros */
-+		fp = DUK_HOBJECT_E_GET_FLAGS_PTR(thr->heap, obj, i);
-+		if (is_freeze && !((*fp) & DUK_PROPDESC_FLAG_ACCESSOR)) {
-+			*fp &= ~(DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE);
-+		} else {
-+			*fp &= ~DUK_PROPDESC_FLAG_CONFIGURABLE;
-+		}
-+	}
-+
-+	DUK_HOBJECT_CLEAR_EXTENSIBLE(obj);
-+
-+	/* no need to compact since we already did that in duk__abandon_array_checked()
-+	 * (regardless of whether an array part existed or not.
-+	 */
-+
-+	return;
-+}
-+
-+/*
-+ *  Object.isSealed() and Object.isFrozen()  (E5 Sections 15.2.3.11, 15.2.3.13)
-+ *
-+ *  Since the algorithms are similar, a helper provides both functions.
-+ *  Freezing is essentially sealing + making plain properties non-writable.
-+ *
-+ *  Note: all virtual (non-concrete) properties are currently non-configurable
-+ *  and non-writable (and there are no accessor virtual properties), so they don't
-+ *  need to be considered here now.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hobject_object_is_sealed_frozen_helper(duk_hthread *thr, duk_hobject *obj, duk_bool_t is_frozen) {
-+	duk_uint_fast32_t i;
-+
-+	DUK_ASSERT(obj != NULL);
-+	DUK_UNREF(thr);
-+
-+	/* Note: no allocation pressure, no need to check refcounts etc */
-+
-+	/* must not be extensible */
-+	if (DUK_HOBJECT_HAS_EXTENSIBLE(obj)) {
-+		return 0;
-+	}
-+
-+	/* all virtual properties are non-configurable and non-writable */
-+
-+	/* entry part must not contain any configurable properties, or
-+	 * writable properties (if is_frozen).
-+	 */
-+	for (i = 0; i < DUK_HOBJECT_GET_ENEXT(obj); i++) {
-+		duk_small_uint_t flags;
-+
-+		if (!DUK_HOBJECT_E_GET_KEY(thr->heap, obj, i)) {
-+			continue;
-+		}
-+
-+		/* avoid multiple computations of flags address; bypasses macros */
-+		flags = (duk_small_uint_t) DUK_HOBJECT_E_GET_FLAGS(thr->heap, obj, i);
-+
-+		if (flags & DUK_PROPDESC_FLAG_CONFIGURABLE) {
-+			return 0;
-+		}
-+		if (is_frozen &&
-+		    !(flags & DUK_PROPDESC_FLAG_ACCESSOR) &&
-+		    (flags & DUK_PROPDESC_FLAG_WRITABLE)) {
-+			return 0;
-+		}
-+	}
-+
-+	/* array part must not contain any non-unused properties, as they would
-+	 * be configurable and writable.
-+	 */
-+	for (i = 0; i < DUK_HOBJECT_GET_ASIZE(obj); i++) {
-+		duk_tval *tv = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, obj, i);
-+		if (!DUK_TVAL_IS_UNDEFINED_UNUSED(tv)) {
-+			return 0;
-+		}
-+	}
-+
-+	return 1;
-+}
-+
-+/*
-+ *  Object.preventExtensions() and Object.isExtensible()  (E5 Sections 15.2.3.10, 15.2.3.13)
-+ *
-+ *  Not needed, implemented by macros DUK_HOBJECT_{HAS,CLEAR,SET}_EXTENSIBLE
-+ *  and the Object built-in bindings.
-+ */
-+
-+/* Undefine local defines */
-+
-+#undef DUK__NO_ARRAY_INDEX
-+#undef DUK__HASH_INITIAL
-+#undef DUK__HASH_PROBE_STEP
-+#undef DUK__HASH_UNUSED
-+#undef DUK__HASH_DELETED
-+#undef DUK__VALSTACK_SPACE
-+#line 1 "duk_hstring_misc.c"
-+/*
-+ *  Misc support functions
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos) {
-+	duk_uint32_t boff;
-+	const duk_uint8_t *p, *p_start, *p_end;
-+	duk_ucodepoint_t cp;
-+
-+	/* Caller must check character offset to be inside the string. */
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(h != NULL);
-+	DUK_ASSERT_DISABLE(pos >= 0);  /* unsigned */
-+	DUK_ASSERT(pos < (duk_uint_t) DUK_HSTRING_GET_CHARLEN(h));
-+
-+	boff = duk_heap_strcache_offset_char2byte(thr, h, (duk_uint32_t) pos);
-+	DUK_DDD(DUK_DDDPRINT("charCodeAt: pos=%ld -> boff=%ld, str=%!O",
-+	                     (long) pos, (long) boff, (duk_heaphdr *) h));
-+	DUK_ASSERT_DISABLE(boff >= 0);
-+	DUK_ASSERT(boff < DUK_HSTRING_GET_BYTELEN(h));
-+
-+	p_start = DUK_HSTRING_GET_DATA(h);
-+	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h);
-+	p = p_start + boff;
-+	DUK_DDD(DUK_DDDPRINT("p_start=%p, p_end=%p, p=%p",
-+	                     (void *) p_start, (void *) p_end, (void *) p));
-+
-+	/* This may throw an error though not for valid E5 strings. */
-+	cp = duk_unicode_decode_xutf8_checked(thr, &p, p_start, p_end);
-+	return cp;
-+}
-+#line 1 "duk_hthread_alloc.c"
-+/*
-+ *  duk_hthread allocation and freeing.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Allocate initial stacks for a thread.  Note that 'thr' must be reachable
-+ *  as a garbage collection may be triggered by the allocation attempts.
-+ *  Returns zero (without leaking memory) if init fails.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_hthread_init_stacks(duk_heap *heap, duk_hthread *thr) {
-+	duk_size_t alloc_size;
-+	duk_size_t i;
-+
-+	DUK_ASSERT(heap != NULL);
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->valstack == NULL);
-+	DUK_ASSERT(thr->valstack_end == NULL);
-+	DUK_ASSERT(thr->valstack_bottom == NULL);
-+	DUK_ASSERT(thr->valstack_top == NULL);
-+	DUK_ASSERT(thr->callstack == NULL);
-+	DUK_ASSERT(thr->catchstack == NULL);
-+
-+	/* valstack */
-+	alloc_size = sizeof(duk_tval) * DUK_VALSTACK_INITIAL_SIZE;
-+	thr->valstack = (duk_tval *) DUK_ALLOC(heap, alloc_size);
-+	if (!thr->valstack) {
-+		goto fail;
-+	}
-+	DUK_MEMZERO(thr->valstack, alloc_size);
-+	thr->valstack_end = thr->valstack + DUK_VALSTACK_INITIAL_SIZE;
-+	thr->valstack_bottom = thr->valstack;
-+	thr->valstack_top = thr->valstack;
-+
-+	for (i = 0; i < DUK_VALSTACK_INITIAL_SIZE; i++) {
-+		DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->valstack[i]);
-+	}
-+
-+	/* callstack */
-+	alloc_size = sizeof(duk_activation) * DUK_CALLSTACK_INITIAL_SIZE;
-+	thr->callstack = (duk_activation *) DUK_ALLOC(heap, alloc_size);
-+	if (!thr->callstack) {
-+		goto fail;
-+	}
-+	DUK_MEMZERO(thr->callstack, alloc_size);
-+	thr->callstack_size = DUK_CALLSTACK_INITIAL_SIZE;
-+	DUK_ASSERT(thr->callstack_top == 0);
-+
-+	/* catchstack */
-+	alloc_size = sizeof(duk_catcher) * DUK_CATCHSTACK_INITIAL_SIZE;
-+	thr->catchstack = (duk_catcher *) DUK_ALLOC(heap, alloc_size);
-+	if (!thr->catchstack) {
-+		goto fail;
-+	}
-+	DUK_MEMZERO(thr->catchstack, alloc_size);
-+	thr->catchstack_size = DUK_CATCHSTACK_INITIAL_SIZE;
-+	DUK_ASSERT(thr->catchstack_top == 0);
-+
-+	return 1;
-+
-+ fail:
-+	DUK_FREE(heap, thr->valstack);
-+	DUK_FREE(heap, thr->callstack);
-+	DUK_FREE(heap, thr->catchstack);
-+
-+	thr->valstack = NULL;
-+	thr->callstack = NULL;
-+	thr->catchstack = NULL;
-+	return 0;
-+}
-+
-+/* For indirect allocs. */
-+
-+DUK_INTERNAL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud) {
-+	duk_hthread *thr = (duk_hthread *) ud;
-+	DUK_UNREF(heap);
-+	return (void *) thr->valstack;
-+}
-+
-+DUK_INTERNAL void *duk_hthread_get_callstack_ptr(duk_heap *heap, void *ud) {
-+	duk_hthread *thr = (duk_hthread *) ud;
-+	DUK_UNREF(heap);
-+	return (void *) thr->callstack;
-+}
-+
-+DUK_INTERNAL void *duk_hthread_get_catchstack_ptr(duk_heap *heap, void *ud) {
-+	duk_hthread *thr = (duk_hthread *) ud;
-+	DUK_UNREF(heap);
-+	return (void *) thr->catchstack;
-+}
-+#line 1 "duk_hthread_builtins.c"
-+/*
-+ *  Initialize built-in objects.  Current thread must have a valstack
-+ *  and initialization errors may longjmp, so a setjmp() catch point
-+ *  must exist.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Encoding constants, must match genbuiltins.py
-+ */
-+
-+#define DUK__CLASS_BITS                  5
-+#define DUK__BIDX_BITS                   6
-+#define DUK__STRIDX_BITS                 9  /* XXX: try to optimize to 8 */
-+#define DUK__NATIDX_BITS                 8
-+#define DUK__NUM_NORMAL_PROPS_BITS       6
-+#define DUK__NUM_FUNC_PROPS_BITS         6
-+#define DUK__PROP_FLAGS_BITS             3
-+#define DUK__STRING_LENGTH_BITS          8
-+#define DUK__STRING_CHAR_BITS            7
-+#define DUK__LENGTH_PROP_BITS            3
-+#define DUK__NARGS_BITS                  3
-+#define DUK__PROP_TYPE_BITS              3
-+#define DUK__MAGIC_BITS                  16
-+
-+#define DUK__NARGS_VARARGS_MARKER        0x07
-+#define DUK__NO_CLASS_MARKER             0x00   /* 0 = DUK_HOBJECT_CLASS_UNUSED */
-+#define DUK__NO_BIDX_MARKER              0x3f
-+#define DUK__NO_STRIDX_MARKER            0xff
-+
-+#define DUK__PROP_TYPE_DOUBLE            0
-+#define DUK__PROP_TYPE_STRING            1
-+#define DUK__PROP_TYPE_STRIDX            2
-+#define DUK__PROP_TYPE_BUILTIN           3
-+#define DUK__PROP_TYPE_UNDEFINED         4
-+#define DUK__PROP_TYPE_BOOLEAN_TRUE      5
-+#define DUK__PROP_TYPE_BOOLEAN_FALSE     6
-+#define DUK__PROP_TYPE_ACCESSOR          7
-+
-+/*
-+ *  Create built-in objects by parsing an init bitstream generated
-+ *  by genbuiltins.py.
-+ */
-+
-+DUK_INTERNAL void duk_hthread_create_builtin_objects(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_bitdecoder_ctx bd_ctx;
-+	duk_bitdecoder_ctx *bd = &bd_ctx;  /* convenience */
-+	duk_hobject *h;
-+	duk_small_uint_t i, j;
-+
-+	DUK_D(DUK_DPRINT("INITBUILTINS BEGIN"));
-+
-+	DUK_MEMZERO(&bd_ctx, sizeof(bd_ctx));
-+	bd->data = (const duk_uint8_t *) duk_builtins_data;
-+	bd->length = (duk_size_t) DUK_BUILTINS_DATA_LENGTH;
-+
-+	/*
-+	 *  First create all built-in bare objects on the empty valstack.
-+	 *  During init, their indices will correspond to built-in indices.
-+	 *
-+	 *  Built-ins will be reachable from both valstack and thr->builtins.
-+	 */
-+
-+	/* XXX: there is no need to resize valstack because builtin count
-+	 * is much less than the default space; assert for it.
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("create empty built-ins"));
-+	DUK_ASSERT_TOP(ctx, 0);
-+	for (i = 0; i < DUK_NUM_BUILTINS; i++) {
-+		duk_small_uint_t class_num;
-+		duk_small_int_t len = -1;  /* must be signed */
-+
-+		class_num = (duk_small_uint_t) duk_bd_decode(bd, DUK__CLASS_BITS);
-+		len = (duk_small_int_t) duk_bd_decode_flagged(bd, DUK__LENGTH_PROP_BITS, (duk_int32_t) -1 /*def_value*/);
-+
-+		if (class_num == DUK_HOBJECT_CLASS_FUNCTION) {
-+			duk_small_uint_t natidx;
-+			duk_small_uint_t stridx;
-+			duk_int_t c_nargs;  /* must hold DUK_VARARGS */
-+			duk_c_function c_func;
-+			duk_int16_t magic;
-+
-+			DUK_DDD(DUK_DDDPRINT("len=%ld", (long) len));
-+			DUK_ASSERT(len >= 0);
-+
-+			natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
-+			stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
-+			c_func = duk_bi_native_functions[natidx];
-+
-+			c_nargs = (duk_small_uint_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, len /*def_value*/);
-+			if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
-+				c_nargs = DUK_VARARGS;
-+			}
-+
-+			/* XXX: set magic directly here? (it could share the c_nargs arg) */
-+			duk_push_c_function_noexotic(ctx, c_func, c_nargs);
-+
-+			h = duk_require_hobject(ctx, -1);
-+			DUK_ASSERT(h != NULL);
-+
-+			/* Currently all built-in native functions are strict.
-+			 * duk_push_c_function() now sets strict flag, so
-+			 * assert for it.
-+			 */
-+			DUK_ASSERT(DUK_HOBJECT_HAS_STRICT(h));
-+
-+			/* XXX: function properties */
-+
-+			duk_push_hstring_stridx(ctx, stridx);
-+			duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
-+
-+			/* Almost all global level Function objects are constructable
-+			 * but not all: Function.prototype is a non-constructable,
-+			 * callable Function.
-+			 */
-+			if (duk_bd_decode_flag(bd)) {
-+				DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(h));
-+			} else {
-+				DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h);
-+			}
-+
-+			/* Cast converts magic to 16-bit signed value */
-+			magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0 /*def_value*/);
-+			((duk_hnativefunction *) h)->magic = magic;
-+		} else {
-+			/* XXX: ARRAY_PART for Array prototype? */
-+
-+			duk_push_object_helper(ctx,
-+			                       DUK_HOBJECT_FLAG_EXTENSIBLE,
-+			                       -1);  /* no prototype or class yet */
-+
-+			h = duk_require_hobject(ctx, -1);
-+			DUK_ASSERT(h != NULL);
-+		}
-+
-+		DUK_HOBJECT_SET_CLASS_NUMBER(h, class_num);
-+
-+		thr->builtins[i] = h;
-+		DUK_HOBJECT_INCREF(thr, &h->hdr);
-+
-+		if (len >= 0) {
-+			/*
-+			 *  For top-level objects, 'length' property has the following
-+			 *  default attributes: non-writable, non-enumerable, non-configurable
-+			 *  (E5 Section 15).
-+			 *
-+			 *  However, 'length' property for Array.prototype has attributes
-+			 *  expected of an Array instance which are different: writable,
-+			 *  non-enumerable, non-configurable (E5 Section 15.4.5.2).
-+			 *
-+			 *  This is currently determined implicitly based on class; there are
-+			 *  no attribute flags in the init data.
-+			 */
-+
-+			duk_push_int(ctx, len);
-+			duk_xdef_prop_stridx(ctx,
-+			                     -2,
-+			                     DUK_STRIDX_LENGTH,
-+			                     (class_num == DUK_HOBJECT_CLASS_ARRAY ?  /* only Array.prototype matches */
-+			                      DUK_PROPDESC_FLAGS_W : DUK_PROPDESC_FLAGS_NONE));
-+		}
-+
-+		/* enable exotic behaviors last */
-+
-+		if (class_num == DUK_HOBJECT_CLASS_ARRAY) {
-+			DUK_HOBJECT_SET_EXOTIC_ARRAY(h);
-+		}
-+		if (class_num == DUK_HOBJECT_CLASS_STRING) {
-+			DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h);
-+		}
-+
-+		/* some assertions */
-+
-+		DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h));
-+		/* DUK_HOBJECT_FLAG_CONSTRUCTABLE varies */
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(h));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_COMPILEDFUNCTION(h));
-+		/* DUK_HOBJECT_FLAG_NATIVEFUNCTION varies */
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(h));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(h));       /* currently, even for Array.prototype */
-+		/* DUK_HOBJECT_FLAG_STRICT varies */
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(h) ||  /* all native functions have NEWENV */
-+		           DUK_HOBJECT_HAS_NEWENV(h));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(h));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(h));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_ENVRECCLOSED(h));
-+		/* DUK_HOBJECT_FLAG_EXOTIC_ARRAY varies */
-+		/* DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ varies */
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h));
-+
-+		DUK_DDD(DUK_DDDPRINT("created built-in %ld, class=%ld, length=%ld", (long) i, (long) class_num, (long) len));
-+	}
-+
-+	/*
-+	 *  Then decode the builtins init data (see genbuiltins.py) to
-+	 *  init objects
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("initialize built-in object properties"));
-+	for (i = 0; i < DUK_NUM_BUILTINS; i++) {
-+		duk_small_uint_t t;
-+		duk_small_uint_t num;
-+
-+		DUK_DDD(DUK_DDDPRINT("initializing built-in object at index %ld", (long) i));
-+		h = thr->builtins[i];
-+
-+		t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
-+		if (t != DUK__NO_BIDX_MARKER) {
-+			DUK_DDD(DUK_DDDPRINT("set internal prototype: built-in %ld", (long) t));
-+			DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[t]);
-+		}
-+
-+		t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
-+		if (t != DUK__NO_BIDX_MARKER) {
-+			/* 'prototype' property for all built-in objects (which have it) has attributes:
-+			 *  [[Writable]] = false,
-+			 *  [[Enumerable]] = false,
-+			 *  [[Configurable]] = false
-+			 */
-+			DUK_DDD(DUK_DDDPRINT("set external prototype: built-in %ld", (long) t));
-+			duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_PROTOTYPE, t, DUK_PROPDESC_FLAGS_NONE);
-+		}
-+
-+		t = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
-+		if (t != DUK__NO_BIDX_MARKER) {
-+			/* 'constructor' property for all built-in objects (which have it) has attributes:
-+			 *  [[Writable]] = true,
-+			 *  [[Enumerable]] = false,
-+			 *  [[Configurable]] = true
-+			 */
-+			DUK_DDD(DUK_DDDPRINT("set external constructor: built-in %ld", (long) t));
-+			duk_xdef_prop_stridx_builtin(ctx, i, DUK_STRIDX_CONSTRUCTOR, t, DUK_PROPDESC_FLAGS_WC);
-+		}
-+
-+		/* normal valued properties */
-+		num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_NORMAL_PROPS_BITS);
-+		DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld normal valued properties", (long) i, (long) num));
-+		for (j = 0; j < num; j++) {
-+			duk_small_uint_t stridx;
-+			duk_small_uint_t prop_flags;
-+
-+			stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
-+
-+			/*
-+			 *  Property attribute defaults are defined in E5 Section 15 (first
-+			 *  few pages); there is a default for all properties and a special
-+			 *  default for 'length' properties.  Variation from the defaults is
-+			 *  signaled using a single flag bit in the bitstream.
-+			 */
-+
-+			if (duk_bd_decode_flag(bd)) {
-+				prop_flags = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_FLAGS_BITS);
-+			} else {
-+				if (stridx == DUK_STRIDX_LENGTH) {
-+					prop_flags = DUK_PROPDESC_FLAGS_NONE;
-+				} else {
-+					prop_flags = DUK_PROPDESC_FLAGS_WC;
-+				}
-+			}
-+
-+			t = (duk_small_uint_t) duk_bd_decode(bd, DUK__PROP_TYPE_BITS);
-+
-+			DUK_DDD(DUK_DDDPRINT("built-in %ld, normal-valued property %ld, stridx %ld, flags 0x%02lx, type %ld",
-+			                     (long) i, (long) j, (long) stridx, (unsigned long) prop_flags, (long) t));
-+
-+			switch (t) {
-+			case DUK__PROP_TYPE_DOUBLE: {
-+				duk_double_union du;
-+				duk_small_uint_t k;
-+
-+				for (k = 0; k < 8; k++) {
-+					/* Encoding endianness must match target memory layout,
-+					 * build scripts and genbuiltins.py must ensure this.
-+					 */
-+					du.uc[k] = (duk_uint8_t) duk_bd_decode(bd, 8);
-+				}
-+
-+				duk_push_number(ctx, du.d);  /* push operation normalizes NaNs */
-+				break;
-+			}
-+			case DUK__PROP_TYPE_STRING: {
-+				duk_small_uint_t n;
-+				duk_small_uint_t k;
-+				duk_uint8_t *p;
-+
-+				n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRING_LENGTH_BITS);
-+				p = (duk_uint8_t *) duk_push_fixed_buffer(ctx, n);
-+				for (k = 0; k < n; k++) {
-+					*p++ = (duk_uint8_t) duk_bd_decode(bd, DUK__STRING_CHAR_BITS);
-+				}
-+
-+				duk_to_string(ctx, -1);
-+				break;
-+			}
-+			case DUK__PROP_TYPE_STRIDX: {
-+				duk_small_uint_t n;
-+
-+				n = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
-+				DUK_ASSERT_DISABLE(n >= 0);  /* unsigned */
-+				DUK_ASSERT(n < DUK_HEAP_NUM_STRINGS);
-+				duk_push_hstring_stridx(ctx, n);
-+				break;
-+			}
-+			case DUK__PROP_TYPE_BUILTIN: {
-+				duk_small_uint_t bidx;
-+
-+				bidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__BIDX_BITS);
-+				DUK_ASSERT(bidx != DUK__NO_BIDX_MARKER);
-+				duk_dup(ctx, (duk_idx_t) bidx);
-+				break;
-+			}
-+			case DUK__PROP_TYPE_UNDEFINED: {
-+				duk_push_undefined(ctx);
-+				break;
-+			}
-+			case DUK__PROP_TYPE_BOOLEAN_TRUE: {
-+				duk_push_true(ctx);
-+				break;
-+			}
-+			case DUK__PROP_TYPE_BOOLEAN_FALSE: {
-+				duk_push_false(ctx);
-+				break;
-+			}
-+			case DUK__PROP_TYPE_ACCESSOR: {
-+				duk_small_uint_t natidx_getter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
-+				duk_small_uint_t natidx_setter = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
-+				duk_c_function c_func_getter;
-+				duk_c_function c_func_setter;
-+
-+				/* XXX: this is a bit awkward because there is no exposed helper
-+				 * in the API style, only this internal helper.
-+				 */
-+				DUK_DDD(DUK_DDDPRINT("built-in accessor property: objidx=%ld, stridx=%ld, getteridx=%ld, setteridx=%ld, flags=0x%04lx",
-+				                     (long) i, (long) stridx, (long) natidx_getter, (long) natidx_setter, (unsigned long) prop_flags));
-+
-+				c_func_getter = duk_bi_native_functions[natidx_getter];
-+				c_func_setter = duk_bi_native_functions[natidx_setter];
-+				duk_push_c_function_noconstruct_noexotic(ctx, c_func_getter, 0);  /* always 0 args */
-+				duk_push_c_function_noconstruct_noexotic(ctx, c_func_setter, 1);  /* always 1 arg */
-+
-+				/* XXX: magic for getter/setter? */
-+
-+				prop_flags |= DUK_PROPDESC_FLAG_ACCESSOR;  /* accessor flag not encoded explicitly */
-+				duk_hobject_define_accessor_internal(thr,
-+				                                     duk_require_hobject(ctx, i),
-+				                                     DUK_HTHREAD_GET_STRING(thr, stridx),
-+				                                     duk_require_hobject(ctx, -2),
-+				                                     duk_require_hobject(ctx, -1),
-+				                                     prop_flags);
-+				duk_pop_2(ctx);  /* getter and setter, now reachable through object */
-+				goto skip_value;
-+			}
-+			default: {
-+				/* exhaustive */
-+				DUK_UNREACHABLE();
-+			}
-+			}
-+
-+			DUK_ASSERT((prop_flags & DUK_PROPDESC_FLAG_ACCESSOR) == 0);
-+			duk_xdef_prop_stridx(ctx, i, stridx, prop_flags);
-+
-+		 skip_value:
-+			continue;  /* avoid empty label at the end of a compound statement */
-+		}
-+
-+		/* native function properties */
-+		num = (duk_small_uint_t) duk_bd_decode(bd, DUK__NUM_FUNC_PROPS_BITS);
-+		DUK_DDD(DUK_DDDPRINT("built-in object %ld, %ld function valued properties", (long) i, (long) num));
-+		for (j = 0; j < num; j++) {
-+			duk_small_uint_t stridx;
-+			duk_small_uint_t natidx;
-+			duk_int_t c_nargs;  /* must hold DUK_VARARGS */
-+			duk_small_uint_t c_length;
-+			duk_int16_t magic;
-+			duk_c_function c_func;
-+			duk_hnativefunction *h_func;
-+#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
-+			duk_small_int_t lightfunc_eligible;
-+#endif
-+
-+			stridx = (duk_small_uint_t) duk_bd_decode(bd, DUK__STRIDX_BITS);
-+			natidx = (duk_small_uint_t) duk_bd_decode(bd, DUK__NATIDX_BITS);
-+
-+			c_length = (duk_small_uint_t) duk_bd_decode(bd, DUK__LENGTH_PROP_BITS);
-+			c_nargs = (duk_int_t) duk_bd_decode_flagged(bd, DUK__NARGS_BITS, (duk_int32_t) c_length /*def_value*/);
-+			if (c_nargs == DUK__NARGS_VARARGS_MARKER) {
-+				c_nargs = DUK_VARARGS;
-+			}
-+
-+			c_func = duk_bi_native_functions[natidx];
-+
-+			DUK_DDD(DUK_DDDPRINT("built-in %ld, function-valued property %ld, stridx %ld, natidx %ld, length %ld, nargs %ld",
-+			                     (long) i, (long) j, (long) stridx, (long) natidx, (long) c_length,
-+			                     (c_nargs == DUK_VARARGS ? (long) -1 : (long) c_nargs)));
-+
-+			/* Cast converts magic to 16-bit signed value */
-+			magic = (duk_int16_t) duk_bd_decode_flagged(bd, DUK__MAGIC_BITS, 0);
-+
-+#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
-+			lightfunc_eligible =
-+				((c_nargs >= DUK_LFUNC_NARGS_MIN && c_nargs <= DUK_LFUNC_NARGS_MAX) || (c_nargs == DUK_VARARGS)) &&
-+				(c_length <= DUK_LFUNC_LENGTH_MAX) &&
-+				(magic >= DUK_LFUNC_MAGIC_MIN && magic <= DUK_LFUNC_MAGIC_MAX);
-+			if (stridx == DUK_STRIDX_EVAL ||
-+			    stridx == DUK_STRIDX_YIELD ||
-+			    stridx == DUK_STRIDX_RESUME ||
-+			    stridx == DUK_STRIDX_REQUIRE) {
-+				/* These functions have trouble working as lightfuncs.
-+				 * Some of them have specific asserts and some may have
-+			         * additional properties (e.g. 'require.id' may be written).
-+				 */
-+				DUK_D(DUK_DPRINT("reject as lightfunc: stridx=%d, i=%d, j=%d", (int) stridx, (int) i, (int) j));
-+				lightfunc_eligible = 0;
-+			}
-+
-+			if (lightfunc_eligible) {
-+				duk_tval tv_lfunc;
-+				duk_small_uint_t lf_nargs = (c_nargs == DUK_VARARGS ? DUK_LFUNC_NARGS_VARARGS : c_nargs);
-+				duk_small_uint_t lf_flags = DUK_LFUNC_FLAGS_PACK(magic, c_length, lf_nargs);
-+				DUK_TVAL_SET_LIGHTFUNC(&tv_lfunc, c_func, lf_flags);
-+				duk_push_tval(ctx, &tv_lfunc);
-+				DUK_D(DUK_DPRINT("built-in function eligible as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld -> %!iT", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic, duk_get_tval(ctx, -1)));
-+				goto lightfunc_skip;
-+			}
-+
-+			DUK_D(DUK_DPRINT("built-in function NOT ELIGIBLE as light function: i=%d, j=%d c_length=%ld, c_nargs=%ld, magic=%ld", (int) i, (int) j, (long) c_length, (long) c_nargs, (long) magic));
-+#endif  /* DUK_USE_LIGHTFUNC_BUILTINS */
-+
-+			/* [ (builtin objects) ] */
-+
-+			duk_push_c_function_noconstruct_noexotic(ctx, c_func, c_nargs);
-+			h_func = duk_require_hnativefunction(ctx, -1);
-+			DUK_UNREF(h_func);
-+
-+			/* Currently all built-in native functions are strict.
-+			 * This doesn't matter for many functions, but e.g.
-+			 * String.prototype.charAt (and other string functions)
-+			 * rely on being strict so that their 'this' binding is
-+			 * not automatically coerced.
-+			 */
-+			DUK_HOBJECT_SET_STRICT((duk_hobject *) h_func);
-+
-+			/* No built-in functions are constructable except the top
-+			 * level ones (Number, etc).
-+			 */
-+			DUK_ASSERT(!DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_func));
-+
-+			/* XXX: any way to avoid decoding magic bit; there are quite
-+			 * many function properties and relatively few with magic values.
-+			 */
-+			h_func->magic = magic;
-+
-+			/* [ (builtin objects) func ] */
-+
-+			duk_push_int(ctx, c_length);
-+			duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
-+
-+			duk_push_hstring_stridx(ctx, stridx);
-+			duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
-+
-+			/* XXX: other properties of function instances; 'arguments', 'caller'. */
-+
-+			DUK_DD(DUK_DDPRINT("built-in object %ld, function property %ld -> %!T",
-+			                   (long) i, (long) j, (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+			/* [ (builtin objects) func ] */
-+
-+			/*
-+			 *  The default property attributes are correct for all
-+			 *  function valued properties of built-in objects now.
-+			 */
-+
-+#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
-+		 lightfunc_skip:
-+#endif
-+
-+			duk_xdef_prop_stridx(ctx, i, stridx, DUK_PROPDESC_FLAGS_WC);
-+
-+			/* [ (builtin objects) ] */
-+		}
-+	}
-+
-+	/*
-+	 *  Special post-tweaks, for cases not covered by the init data format.
-+	 *
-+	 *  - Set Date.prototype.toGMTString to Date.prototype.toUTCString.
-+	 *    toGMTString is required to have the same Function object as
-+	 *    toUTCString in E5 Section B.2.6.  Note that while Smjs respects
-+	 *    this, V8 does not (the Function objects are distinct).
-+	 *
-+	 *  - Make DoubleError non-extensible.
-+	 *
-+	 *  - Add info about most important effective compile options to Duktape.
-+	 *
-+	 *  - Possibly remove some properties (values or methods) which are not
-+	 *    desirable with current feature options but are not currently
-+	 *    conditional in init data.
-+	 */
-+
-+	duk_get_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_UTC_STRING);
-+	duk_xdef_prop_stridx(ctx, DUK_BIDX_DATE_PROTOTYPE, DUK_STRIDX_TO_GMT_STRING, DUK_PROPDESC_FLAGS_WC);
-+
-+	h = duk_require_hobject(ctx, DUK_BIDX_DOUBLE_ERROR);
-+	DUK_ASSERT(h != NULL);
-+	DUK_HOBJECT_CLEAR_EXTENSIBLE(h);
-+
-+#if !defined(DUK_USE_ES6_OBJECT_PROTO_PROPERTY)
-+	DUK_DD(DUK_DDPRINT("delete Object.prototype.__proto__ built-in which is not enabled in features"));
-+	(void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_PROTOTYPE], DUK_HTHREAD_STRING___PROTO__(thr), DUK_DELPROP_FLAG_THROW);
-+#endif
-+
-+#if !defined(DUK_USE_ES6_OBJECT_SETPROTOTYPEOF)
-+	DUK_DD(DUK_DDPRINT("delete Object.setPrototypeOf built-in which is not enabled in features"));
-+	(void) duk_hobject_delprop_raw(thr, thr->builtins[DUK_BIDX_OBJECT_CONSTRUCTOR], DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr), DUK_DELPROP_FLAG_THROW);
-+#endif
-+
-+	duk_push_string(ctx,
-+			/* Endianness indicator */
-+#if defined(DUK_USE_INTEGER_LE)
-+	                "l"
-+#elif defined(DUK_USE_INTEGER_BE)
-+	                "b"
-+#elif defined(DUK_USE_INTEGER_ME)  /* integer mixed endian not really used now */
-+	                "m"
-+#else
-+	                "?"
-+#endif
-+#if defined(DUK_USE_DOUBLE_LE)
-+	                "l"
-+#elif defined(DUK_USE_DOUBLE_BE)
-+	                "b"
-+#elif defined(DUK_USE_DOUBLE_ME)
-+	                "m"
-+#else
-+	                "?"
-+#endif
-+#if defined(DUK_USE_BYTEORDER_FORCED)
-+			"f"
-+#endif
-+	                " "
-+			/* Packed or unpacked tval */
-+#if defined(DUK_USE_PACKED_TVAL)
-+	                "p"
-+#else
-+	                "u"
-+#endif
-+#if defined(DUK_USE_FASTINT)
-+			"f"
-+#endif
-+			" "
-+			/* Low memory options */
-+#if defined(DUK_USE_STRTAB_CHAIN)
-+			"c"  /* chain */
-+#elif defined(DUK_USE_STRTAB_PROBE)
-+			"p"  /* probe */
-+#else
-+			"?"
-+#endif
-+#if !defined(DUK_USE_HEAPPTR16) && !defined(DUK_DATAPTR16) && !defined(DUK_FUNCPTR16)
-+			"n"
-+#endif
-+#if defined(DUK_USE_HEAPPTR16)
-+			"h"
-+#endif
-+#if defined(DUK_USE_DATAPTR16)
-+			"d"
-+#endif
-+#if defined(DUK_USE_FUNCPTR16)
-+			"f"
-+#endif
-+#if defined(DUK_USE_REFCOUNT16)
-+			"R"
-+#endif
-+#if defined(DUK_USE_STRHASH16)
-+			"H"
-+#endif
-+#if defined(DUK_USE_STRLEN16)
-+			"S"
-+#endif
-+#if defined(DUK_USE_BUFLEN16)
-+			"B"
-+#endif
-+#if defined(DUK_USE_OBJSIZES16)
-+			"O"
-+#endif
-+#if defined(DUK_USE_LIGHTFUNC_BUILTINS)
-+			"L"
-+#endif
-+	                " "
-+			/* Object property allocation layout */
-+#if defined(DUK_USE_HOBJECT_LAYOUT_1)
-+			"p1"
-+#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
-+			"p2"
-+#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
-+			"p3"
-+#else
-+			"p?"
-+#endif
-+			" "
-+			/* Alignment guarantee */
-+#if defined(DUK_USE_ALIGN_4)
-+			"a4"
-+#elif defined(DUK_USE_ALIGN_8)
-+			"a8"
-+#else
-+			"a1"
-+#endif
-+			" "
-+			/* Architecture, OS, and compiler strings */
-+	                DUK_USE_ARCH_STRING
-+			" "
-+	                DUK_USE_OS_STRING
-+			" "
-+	                DUK_USE_COMPILER_STRING);
-+	duk_xdef_prop_stridx(ctx, DUK_BIDX_DUKTAPE, DUK_STRIDX_ENV, DUK_PROPDESC_FLAGS_WC);
-+
-+	/*
-+	 *  InitJS code - Ecmascript code evaluated from a built-in source
-+	 *  which provides e.g. backward compatibility.  User can also provide
-+	 *  JS code to be evaluated at startup.
-+	 */
-+
-+#ifdef DUK_USE_BUILTIN_INITJS
-+	/* XXX: compression */
-+	DUK_DD(DUK_DDPRINT("running built-in initjs"));
-+	duk_eval_string(ctx, (const char *) duk_initjs_data);  /* initjs data is NUL terminated */
-+	duk_pop(ctx);
-+#endif  /* DUK_USE_BUILTIN_INITJS */
-+
-+#ifdef DUK_USE_USER_INITJS
-+	/* XXX: compression (as an option) */
-+	DUK_DD(DUK_DDPRINT("running user initjs"));
-+	duk_eval_string_noresult(ctx, (const char *) DUK_USE_USER_INITJS);
-+#endif  /* DUK_USE_USER_INITJS */
-+
-+	/*
-+	 *  Since built-ins are not often extended, compact them.
-+	 */
-+
-+	DUK_DD(DUK_DDPRINT("compact built-ins"));
-+	for (i = 0; i < DUK_NUM_BUILTINS; i++) {
-+		duk_hobject_compact_props(thr, thr->builtins[i]);
-+	}
-+
-+	DUK_D(DUK_DPRINT("INITBUILTINS END"));
-+
-+#ifdef DUK_USE_DDPRINT
-+	for (i = 0; i < DUK_NUM_BUILTINS; i++) {
-+		DUK_DD(DUK_DDPRINT("built-in object %ld after initialization and compacting: %!@iO",
-+		                   (long) i, (duk_heaphdr *) thr->builtins[i]));
-+	}
-+#endif
-+
-+	/*
-+	 *  Pop built-ins from stack: they are now INCREF'd and
-+	 *  reachable from the builtins[] array.
-+	 */
-+
-+	duk_pop_n(ctx, DUK_NUM_BUILTINS);
-+	DUK_ASSERT_TOP(ctx, 0);
-+}
-+
-+DUK_INTERNAL void duk_hthread_copy_builtin_objects(duk_hthread *thr_from, duk_hthread *thr_to) {
-+	duk_small_uint_t i;
-+
-+	for (i = 0; i < DUK_NUM_BUILTINS; i++) {
-+		thr_to->builtins[i] = thr_from->builtins[i];
-+		DUK_HOBJECT_INCREF_ALLOWNULL(thr_to, thr_to->builtins[i]);  /* side effect free */
-+	}
-+}
-+#line 1 "duk_hthread_misc.c"
-+/*
-+ *  Thread support.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL void duk_hthread_terminate(duk_hthread *thr) {
-+	DUK_ASSERT(thr != NULL);
-+
-+	/* Order of unwinding is important */
-+
-+	duk_hthread_catchstack_unwind(thr, 0);
-+
-+	duk_hthread_callstack_unwind(thr, 0);  /* side effects, possibly errors */
-+
-+	thr->valstack_bottom = thr->valstack;
-+	duk_set_top((duk_context *) thr, 0);  /* unwinds valstack, updating refcounts */
-+
-+	thr->state = DUK_HTHREAD_STATE_TERMINATED;
-+
-+	/* Here we could remove references to built-ins, but it may not be
-+	 * worth the effort because built-ins are quite likely to be shared
-+	 * with another (unterminated) thread, and terminated threads are also
-+	 * usually garbage collected quite quickly.  Also, doing DECREFs
-+	 * could trigger finalization, which would run on the current thread
-+	 * and have access to only some of the built-ins.  Garbage collection
-+	 * deals with this correctly already.
-+	 */
-+
-+	/* XXX: Shrink the stacks to minimize memory usage?  May not
-+	 * be worth the effort because terminated threads are usually
-+	 * garbage collected quite soon.
-+	 */
-+}
-+
-+DUK_INTERNAL duk_activation *duk_hthread_get_current_activation(duk_hthread *thr) {
-+	DUK_ASSERT(thr != NULL);
-+
-+	if (thr->callstack_top > 0) {
-+		return thr->callstack + thr->callstack_top - 1;
-+	} else {
-+		return NULL;
-+	}
-+}
-+#line 1 "duk_hthread_stacks.c"
-+/*
-+ *  Manipulation of thread stacks (valstack, callstack, catchstack).
-+ *
-+ *  Ideally unwinding of stacks should have no side effects, which would
-+ *  then favor separate unwinding and shrink check primitives for each
-+ *  stack type.  A shrink check may realloc and thus have side effects.
-+ *
-+ *  However, currently callstack unwinding itself has side effects, as it
-+ *  needs to DECREF multiple objects, close environment records, etc.
-+ *  Stacks must thus be unwound in the correct order by the caller.
-+ *
-+ *  (XXX: This should be probably reworked so that there is a shared
-+ *  unwind primitive which handles all stacks as requested, and knows
-+ *  the proper order for unwinding.)
-+ *
-+ *  Valstack entries above 'top' are always kept initialized to
-+ *  "undefined unused".  Callstack and catchstack entries above 'top'
-+ *  are not zeroed and are left as garbage.
-+ *
-+ *  Value stack handling is mostly a part of the API implementation.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* check that there is space for at least one new entry */
-+DUK_INTERNAL void duk_hthread_callstack_grow(duk_hthread *thr) {
-+	duk_activation *new_ptr;
-+	duk_size_t old_size;
-+	duk_size_t new_size;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT_DISABLE(thr->callstack_top >= 0);   /* avoid warning (unsigned) */
-+	DUK_ASSERT(thr->callstack_size >= thr->callstack_top);
-+
-+	if (thr->callstack_top < thr->callstack_size) {
-+		return;
-+	}
-+
-+	old_size = thr->callstack_size;
-+	new_size = old_size + DUK_CALLSTACK_GROW_STEP;
-+
-+	/* this is a bit approximate (errors out before max is reached); this is OK */
-+	if (new_size >= thr->callstack_max) {
-+		DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_CALLSTACK_LIMIT);
-+	}
-+
-+	DUK_DD(DUK_DDPRINT("growing callstack %ld -> %ld", (long) old_size, (long) new_size));
-+
-+	/*
-+	 *  Note: must use indirect variant of DUK_REALLOC() because underlying
-+	 *  pointer may be changed by mark-and-sweep.
-+	 */
-+
-+	DUK_ASSERT(new_size > 0);
-+	new_ptr = (duk_activation *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_callstack_ptr, (void *) thr, sizeof(duk_activation) * new_size);
-+	if (!new_ptr) {
-+		/* No need for a NULL/zero-size check because new_size > 0) */
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_REALLOC_FAILED);
-+	}
-+	thr->callstack = new_ptr;
-+	thr->callstack_size = new_size;
-+
-+	/* note: any entries above the callstack top are garbage and not zeroed */
-+}
-+
-+DUK_INTERNAL void duk_hthread_callstack_shrink_check(duk_hthread *thr) {
-+	duk_size_t new_size;
-+	duk_activation *p;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT_DISABLE(thr->callstack_top >= 0);  /* avoid warning (unsigned) */
-+	DUK_ASSERT(thr->callstack_size >= thr->callstack_top);
-+
-+	if (thr->callstack_size - thr->callstack_top < DUK_CALLSTACK_SHRINK_THRESHOLD) {
-+		return;
-+	}
-+
-+	new_size = thr->callstack_top + DUK_CALLSTACK_SHRINK_SPARE;
-+	DUK_ASSERT(new_size >= thr->callstack_top);
-+
-+	DUK_DD(DUK_DDPRINT("shrinking callstack %ld -> %ld", (long) thr->callstack_size, (long) new_size));
-+
-+	/*
-+	 *  Note: must use indirect variant of DUK_REALLOC() because underlying
-+	 *  pointer may be changed by mark-and-sweep.
-+	 */
-+
-+	/* shrink failure is not fatal */
-+	p = (duk_activation *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_callstack_ptr, (void *) thr, sizeof(duk_activation) * new_size);
-+	if (p) {
-+		thr->callstack = p;
-+		thr->callstack_size = new_size;
-+	} else {
-+		/* Because new_size != 0, if condition doesn't need to be
-+		 * (p != NULL || new_size == 0).
-+		 */
-+		DUK_ASSERT(new_size != 0);
-+		DUK_D(DUK_DPRINT("callstack shrink failed, ignoring"));
-+	}
-+
-+	/* note: any entries above the callstack top are garbage and not zeroed */
-+}
-+
-+DUK_INTERNAL void duk_hthread_callstack_unwind(duk_hthread *thr, duk_size_t new_top) {
-+	duk_size_t idx;
-+
-+	DUK_DDD(DUK_DDDPRINT("unwind callstack top of thread %p from %ld to %ld",
-+	                     (void *) thr,
-+	                     (thr != NULL ? (long) thr->callstack_top : (long) -1),
-+	                     (long) new_top));
-+
-+	DUK_ASSERT(thr);
-+	DUK_ASSERT(thr->heap);
-+	DUK_ASSERT_DISABLE(new_top >= 0);  /* unsigned */
-+	DUK_ASSERT((duk_size_t) new_top <= thr->callstack_top);  /* cannot grow */
-+
-+	/*
-+	 *  The loop below must avoid issues with potential callstack
-+	 *  reallocations.  A resize (and other side effects) may happen
-+	 *  e.g. due to finalizer/errhandler calls caused by a refzero or
-+	 *  mark-and-sweep.  Arbitrary finalizers may run, because when
-+	 *  an environment record is refzero'd, it may refer to arbitrary
-+	 *  values which also become refzero'd.
-+	 *
-+	 *  So, the pointer 'p' is re-looked-up below whenever a side effect
-+	 *  might have changed it.
-+	 */
-+
-+	idx = thr->callstack_top;
-+	while (idx > new_top) {
-+		duk_activation *act;
-+		duk_hobject *func;
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		duk_hobject *tmp;
-+#endif
-+#ifdef DUK_USE_DEBUGGER_SUPPORT
-+		duk_heap *heap;
-+#endif
-+
-+		idx--;
-+		DUK_ASSERT_DISABLE(idx >= 0);  /* unsigned */
-+		DUK_ASSERT((duk_size_t) idx < thr->callstack_size);  /* true, despite side effect resizes */
-+
-+		act = thr->callstack + idx;
-+		/* With lightfuncs, act 'func' may be NULL */
-+
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+		/*
-+		 *  Restore 'caller' property for non-strict callee functions.
-+		 */
-+
-+		func = DUK_ACT_GET_FUNC(act);
-+		if (func != NULL && !DUK_HOBJECT_HAS_STRICT(func)) {
-+			duk_tval *tv_caller;
-+			duk_tval tv_tmp;
-+			duk_hobject *h_tmp;
-+
-+			tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr));
-+
-+			/* The act->prev_caller should only be set if the entry for 'caller'
-+			 * exists (as it is only set in that case, and the property is not
-+			 * configurable), but handle all the cases anyway.
-+			 */
-+
-+			if (tv_caller) {
-+				DUK_TVAL_SET_TVAL(&tv_tmp, tv_caller);
-+				if (act->prev_caller) {
-+					/* Just transfer the refcount from act->prev_caller to tv_caller,
-+					 * so no need for a refcount update.  This is the expected case.
-+					 */
-+					DUK_TVAL_SET_OBJECT(tv_caller, act->prev_caller);
-+					act->prev_caller = NULL;
-+				} else {
-+					DUK_TVAL_SET_NULL(tv_caller);   /* no incref needed */
-+					DUK_ASSERT(act->prev_caller == NULL);
-+				}
-+				DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+			} else {
-+				h_tmp = act->prev_caller;
-+				if (h_tmp) {
-+					act->prev_caller = NULL;
-+					DUK_HOBJECT_DECREF(thr, h_tmp);  /* side effects */
-+				}
-+			}
-+			act = thr->callstack + idx;  /* avoid side effects */
-+			DUK_ASSERT(act->prev_caller == NULL);
-+		}
-+#endif
-+
-+		/*
-+		 *  Unwind debugger state.  If we unwind while stepping
-+		 *  (either step over or step into), pause execution.
-+		 */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+		heap = thr->heap;
-+		if (heap->dbg_step_thread == thr &&
-+		    heap->dbg_step_csindex == idx) {
-+			/* Pause for all step types: step into, step over, step out.
-+			 * This is the only place explicitly handling a step out.
-+			 */
-+			DUK_HEAP_SET_PAUSED(heap);
-+			DUK_ASSERT(heap->dbg_step_thread == NULL);
-+		}
-+#endif
-+
-+		/*
-+		 *  Close environment record(s) if they exist.
-+		 *
-+		 *  Only variable environments are closed.  If lex_env != var_env, it
-+		 *  cannot currently contain any register bound declarations.
-+		 *
-+		 *  Only environments created for a NEWENV function are closed.  If an
-+		 *  environment is created for e.g. an eval call, it must not be closed.
-+		 */
-+
-+		func = DUK_ACT_GET_FUNC(act);
-+		if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) {
-+			DUK_DDD(DUK_DDDPRINT("skip closing environments, envs not owned by this activation"));
-+			goto skip_env_close;
-+		}
-+		/* func is NULL for lightfunc */
-+
-+		DUK_ASSERT(act->lex_env == act->var_env);
-+		if (act->var_env != NULL) {
-+			DUK_DDD(DUK_DDDPRINT("closing var_env record %p -> %!O",
-+			                     (void *) act->var_env, (duk_heaphdr *) act->var_env));
-+			duk_js_close_environment_record(thr, act->var_env, func, act->idx_bottom);
-+			act = thr->callstack + idx;  /* avoid side effect issues */
-+		}
-+
-+#if 0
-+		if (act->lex_env != NULL) {
-+			if (act->lex_env == act->var_env) {
-+				/* common case, already closed, so skip */
-+				DUK_DD(DUK_DDPRINT("lex_env and var_env are the same and lex_env "
-+				                   "already closed -> skip closing lex_env"));
-+				;
-+			} else {
-+				DUK_DD(DUK_DDPRINT("closing lex_env record %p -> %!O",
-+				                   (void *) act->lex_env, (duk_heaphdr *) act->lex_env));
-+				duk_js_close_environment_record(thr, act->lex_env, DUK_ACT_GET_FUNC(act), act->idx_bottom);
-+				act = thr->callstack + idx;  /* avoid side effect issues */
-+			}
-+		}
-+#endif
-+
-+		DUK_ASSERT((act->lex_env == NULL) ||
-+		           ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) &&
-+		            (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) &&
-+		            (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) &&
-+		            (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->lex_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL)));
-+
-+		DUK_ASSERT((act->var_env == NULL) ||
-+		           ((duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL) &&
-+		            (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_VARMAP(thr)) == NULL) &&
-+		            (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL) &&
-+		            (duk_hobject_find_existing_entry_tval_ptr(thr->heap, act->var_env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL)));
-+
-+	 skip_env_close:
-+
-+		/*
-+		 *  Update preventcount
-+		 */
-+
-+		if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
-+			DUK_ASSERT(thr->callstack_preventcount >= 1);
-+			thr->callstack_preventcount--;
-+		}
-+
-+		/*
-+		 *  Reference count updates
-+		 *
-+		 *  Note: careful manipulation of refcounts.  The top is
-+		 *  not updated yet, so all the activations are reachable
-+		 *  for mark-and-sweep (which may be triggered by decref).
-+		 *  However, the pointers are NULL so this is not an issue.
-+		 */
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		tmp = act->var_env;
-+#endif
-+		act->var_env = NULL;
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+		act = thr->callstack + idx;  /* avoid side effect issues */
-+#endif
-+
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		tmp = act->lex_env;
-+#endif
-+		act->lex_env = NULL;
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+		act = thr->callstack + idx;  /* avoid side effect issues */
-+#endif
-+
-+		/* Note: this may cause a corner case situation where a finalizer
-+		 * may see a currently reachable activation whose 'func' is NULL.
-+		 */
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		tmp = DUK_ACT_GET_FUNC(act);
-+#endif
-+		act->func = NULL;
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+		act = thr->callstack + idx;  /* avoid side effect issues */
-+		DUK_UNREF(act);
-+#endif
-+	}
-+
-+	thr->callstack_top = new_top;
-+
-+	/*
-+	 *  We could clear the book-keeping variables for the topmost activation,
-+	 *  but don't do so now.
-+	 */
-+#if 0
-+	if (thr->callstack_top > 0) {
-+		duk_activation *act = thr->callstack + thr->callstack_top - 1;
-+		act->idx_retval = 0;
-+	}
-+#endif
-+
-+	/* Note: any entries above the callstack top are garbage and not zeroed.
-+	 * Also topmost activation idx_retval is garbage (not zeroed), and must
-+	 * be ignored.
-+	 */
-+}
-+
-+DUK_INTERNAL void duk_hthread_catchstack_grow(duk_hthread *thr) {
-+	duk_catcher *new_ptr;
-+	duk_size_t old_size;
-+	duk_size_t new_size;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT_DISABLE(thr->catchstack_top);  /* avoid warning (unsigned) */
-+	DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top);
-+
-+	if (thr->catchstack_top < thr->catchstack_size) {
-+		return;
-+	}
-+
-+	old_size = thr->catchstack_size;
-+	new_size = old_size + DUK_CATCHSTACK_GROW_STEP;
-+
-+	/* this is a bit approximate (errors out before max is reached); this is OK */
-+	if (new_size >= thr->catchstack_max) {
-+		DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_CATCHSTACK_LIMIT);
-+	}
-+
-+	DUK_DD(DUK_DDPRINT("growing catchstack %ld -> %ld", (long) old_size, (long) new_size));
-+
-+	/*
-+	 *  Note: must use indirect variant of DUK_REALLOC() because underlying
-+	 *  pointer may be changed by mark-and-sweep.
-+	 */
-+
-+	DUK_ASSERT(new_size > 0);
-+	new_ptr = (duk_catcher *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_catchstack_ptr, (void *) thr, sizeof(duk_catcher) * new_size);
-+	if (!new_ptr) {
-+		/* No need for a NULL/zero-size check because new_size > 0) */
-+		DUK_ERROR(thr, DUK_ERR_ALLOC_ERROR, DUK_STR_REALLOC_FAILED);
-+	}
-+	thr->catchstack = new_ptr;
-+	thr->catchstack_size = new_size;
-+
-+	/* note: any entries above the catchstack top are garbage and not zeroed */
-+}
-+
-+DUK_INTERNAL void duk_hthread_catchstack_shrink_check(duk_hthread *thr) {
-+	duk_size_t new_size;
-+	duk_catcher *p;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT_DISABLE(thr->catchstack_top >= 0);  /* avoid warning (unsigned) */
-+	DUK_ASSERT(thr->catchstack_size >= thr->catchstack_top);
-+
-+	if (thr->catchstack_size - thr->catchstack_top < DUK_CATCHSTACK_SHRINK_THRESHOLD) {
-+		return;
-+	}
-+
-+	new_size = thr->catchstack_top + DUK_CATCHSTACK_SHRINK_SPARE;
-+	DUK_ASSERT(new_size >= thr->catchstack_top);
-+
-+	DUK_DD(DUK_DDPRINT("shrinking catchstack %ld -> %ld", (long) thr->catchstack_size, (long) new_size));
-+
-+	/*
-+	 *  Note: must use indirect variant of DUK_REALLOC() because underlying
-+	 *  pointer may be changed by mark-and-sweep.
-+	 */
-+
-+	/* shrink failure is not fatal */
-+	p = (duk_catcher *) DUK_REALLOC_INDIRECT(thr->heap, duk_hthread_get_catchstack_ptr, (void *) thr, sizeof(duk_catcher) * new_size);
-+	if (p) {
-+		thr->catchstack = p;
-+		thr->catchstack_size = new_size;
-+	} else {
-+		/* Because new_size != 0, if condition doesn't need to be
-+		 * (p != NULL || new_size == 0).
-+		 */
-+		DUK_ASSERT(new_size != 0);
-+		DUK_D(DUK_DPRINT("catchstack shrink failed, ignoring"));
-+	}
-+
-+	/* note: any entries above the catchstack top are garbage and not zeroed */
-+}
-+
-+DUK_INTERNAL void duk_hthread_catchstack_unwind(duk_hthread *thr, duk_size_t new_top) {
-+	duk_size_t idx;
-+
-+	DUK_DDD(DUK_DDDPRINT("unwind catchstack top of thread %p from %ld to %ld",
-+	                     (void *) thr,
-+	                     (thr != NULL ? (long) thr->catchstack_top : (long) -1),
-+	                     (long) new_top));
-+
-+	DUK_ASSERT(thr);
-+	DUK_ASSERT(thr->heap);
-+	DUK_ASSERT_DISABLE(new_top >= 0);  /* unsigned */
-+	DUK_ASSERT((duk_size_t) new_top <= thr->catchstack_top);  /* cannot grow */
-+
-+	/*
-+	 *  Since there are no references in the catcher structure,
-+	 *  unwinding is quite simple.  The only thing we need to
-+	 *  look out for is popping a possible lexical environment
-+	 *  established for an active catch clause.
-+	 */
-+
-+	idx = thr->catchstack_top;
-+	while (idx > new_top) {
-+		duk_catcher *p;
-+		duk_activation *act;
-+		duk_hobject *env;
-+
-+		idx--;
-+		DUK_ASSERT_DISABLE(idx >= 0);  /* unsigned */
-+		DUK_ASSERT((duk_size_t) idx < thr->catchstack_size);
-+
-+		p = thr->catchstack + idx;
-+
-+		if (DUK_CAT_HAS_LEXENV_ACTIVE(p)) {
-+			DUK_DDD(DUK_DDDPRINT("unwinding catchstack idx %ld, callstack idx %ld, callstack top %ld: lexical environment active",
-+			                     (long) idx, (long) p->callstack_index, (long) thr->callstack_top));
-+
-+			/* XXX: Here we have a nasty dependency: the need to manipulate
-+			 * the callstack means that catchstack must always be unwound by
-+			 * the caller before unwinding the callstack.  This should be fixed
-+			 * later.
-+			 */
-+
-+			/* Note that multiple catchstack entries may refer to the same
-+			 * callstack entry.
-+			 */
-+			act = thr->callstack + p->callstack_index;
-+			DUK_ASSERT(act >= thr->callstack);
-+			DUK_ASSERT(act < thr->callstack + thr->callstack_top);
-+
-+			DUK_DDD(DUK_DDDPRINT("catchstack_index=%ld, callstack_index=%ld, lex_env=%!iO",
-+			                     (long) idx, (long) p->callstack_index,
-+			                     (duk_heaphdr *) act->lex_env));
-+
-+			env = act->lex_env;             /* current lex_env of the activation (created for catcher) */
-+			DUK_ASSERT(env != NULL);        /* must be, since env was created when catcher was created */
-+			act->lex_env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, env);  /* prototype is lex_env before catcher created */
-+			DUK_HOBJECT_DECREF(thr, env);
-+
-+			/* There is no need to decref anything else than 'env': if 'env'
-+			 * becomes unreachable, refzero will handle decref'ing its prototype.
-+			 */
-+		}
-+	}
-+
-+	thr->catchstack_top = new_top;
-+
-+	/* note: any entries above the catchstack top are garbage and not zeroed */
-+}
-+#line 1 "duk_js_call.c"
-+/*
-+ *  Call handling.
-+ *
-+ *  The main work horse functions are:
-+ *    - duk_handle_call(): call to a C/Ecmascript functions
-+ *    - duk_handle_safe_call(): make a protected C call within current activation
-+ *    - duk_handle_ecma_call_setup(): Ecmascript-to-Ecmascript calls, including
-+ *      tail calls and coroutine resume
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Arguments object creation.
-+ *
-+ *  Creating arguments objects is a bit finicky, see E5 Section 10.6 for the
-+ *  specific requirements.  Much of the arguments object exotic behavior is
-+ *  implemented in duk_hobject_props.c, and is enabled by the object flag
-+ *  DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS.
-+ */
-+
-+DUK_LOCAL
-+void duk__create_arguments_object(duk_hthread *thr,
-+                                  duk_hobject *func,
-+                                  duk_hobject *varenv,
-+                                  duk_idx_t idx_argbase,        /* idx of first argument on stack */
-+                                  duk_idx_t num_stack_args) {   /* num args starting from idx_argbase */
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *arg;          /* 'arguments' */
-+	duk_hobject *formals;      /* formals for 'func' (may be NULL if func is a C function) */
-+	duk_idx_t i_arg;
-+	duk_idx_t i_map;
-+	duk_idx_t i_mappednames;
-+	duk_idx_t i_formals;
-+	duk_idx_t i_argbase;
-+	duk_idx_t n_formals;
-+	duk_idx_t idx;
-+	duk_bool_t need_map;
-+
-+	DUK_DDD(DUK_DDDPRINT("creating arguments object for func=%!iO, varenv=%!iO, "
-+	                     "idx_argbase=%ld, num_stack_args=%ld",
-+	                     (duk_heaphdr *) func, (duk_heaphdr *) varenv,
-+	                     (long) idx_argbase, (long) num_stack_args));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_NONBOUND_FUNCTION(func));
-+	DUK_ASSERT(varenv != NULL);
-+	DUK_ASSERT(idx_argbase >= 0);  /* assumed to bottom relative */
-+	DUK_ASSERT(num_stack_args >= 0);
-+
-+	need_map = 0;
-+
-+	i_argbase = idx_argbase;
-+	DUK_ASSERT(i_argbase >= 0);
-+
-+	duk_push_hobject(ctx, func);
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_FORMALS);
-+	formals = duk_get_hobject(ctx, -1);
-+	n_formals = 0;
-+	if (formals) {
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH);
-+		n_formals = (duk_idx_t) duk_require_int(ctx, -1);
-+		duk_pop(ctx);
-+	}
-+	duk_remove(ctx, -2);  /* leave formals on stack for later use */
-+	i_formals = duk_require_top_index(ctx);
-+
-+	DUK_ASSERT(n_formals >= 0);
-+	DUK_ASSERT(formals != NULL || n_formals == 0);
-+
-+	DUK_DDD(DUK_DDDPRINT("func=%!O, formals=%!O, n_formals=%ld",
-+	                     (duk_heaphdr *) func, (duk_heaphdr *) formals,
-+	                     (long) n_formals));
-+
-+	/* [ ... formals ] */
-+
-+	/*
-+	 *  Create required objects:
-+	 *    - 'arguments' object: array-like, but not an array
-+	 *    - 'map' object: internal object, tied to 'arguments'
-+	 *    - 'mappedNames' object: temporary value used during construction
-+	 */
-+
-+	i_arg = duk_push_object_helper(ctx,
-+	                               DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                               DUK_HOBJECT_FLAG_ARRAY_PART |
-+	                               DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_ARGUMENTS),
-+	                               DUK_BIDX_OBJECT_PROTOTYPE);
-+	DUK_ASSERT(i_arg >= 0);
-+	arg = duk_require_hobject(ctx, -1);
-+	DUK_ASSERT(arg != NULL);
-+
-+	i_map = duk_push_object_helper(ctx,
-+	                               DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                               DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-+	                               -1);  /* no prototype */
-+	DUK_ASSERT(i_map >= 0);
-+
-+	i_mappednames = duk_push_object_helper(ctx,
-+	                                       DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                                       DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJECT),
-+	                                       -1);  /* no prototype */
-+	DUK_ASSERT(i_mappednames >= 0);
-+
-+	/* [... formals arguments map mappedNames] */
-+
-+	DUK_DDD(DUK_DDDPRINT("created arguments related objects: "
-+	                     "arguments at index %ld -> %!O "
-+	                     "map at index %ld -> %!O "
-+	                     "mappednames at index %ld -> %!O",
-+	                     (long) i_arg, (duk_heaphdr *) duk_get_hobject(ctx, i_arg),
-+	                     (long) i_map, (duk_heaphdr *) duk_get_hobject(ctx, i_map),
-+	                     (long) i_mappednames, (duk_heaphdr *) duk_get_hobject(ctx, i_mappednames)));
-+
-+	/*
-+	 *  Init arguments properties, map, etc.
-+	 */
-+
-+	duk_push_int(ctx, num_stack_args);
-+	duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_WC);
-+
-+	/*
-+	 *  Init argument related properties
-+	 */
-+
-+	/* step 11 */
-+	idx = num_stack_args - 1;
-+	while (idx >= 0) {
-+		DUK_DDD(DUK_DDDPRINT("arg idx %ld, argbase=%ld, argidx=%ld",
-+		                     (long) idx, (long) i_argbase, (long) (i_argbase + idx)));
-+
-+		DUK_DDD(DUK_DDDPRINT("define arguments[%ld]=arg", (long) idx));
-+		duk_dup(ctx, i_argbase + idx);
-+		duk_xdef_prop_index_wec(ctx, i_arg, (duk_uarridx_t) idx);
-+		DUK_DDD(DUK_DDDPRINT("defined arguments[%ld]=arg", (long) idx));
-+
-+		/* step 11.c is relevant only if non-strict (checked in 11.c.ii) */
-+		if (!DUK_HOBJECT_HAS_STRICT(func) && idx < n_formals) {
-+			DUK_ASSERT(formals != NULL);
-+
-+			DUK_DDD(DUK_DDDPRINT("strict function, index within formals (%ld < %ld)",
-+			                     (long) idx, (long) n_formals));
-+
-+			duk_get_prop_index(ctx, i_formals, idx);
-+			DUK_ASSERT(duk_is_string(ctx, -1));
-+
-+			duk_dup(ctx, -1);  /* [... name name] */
-+
-+			if (!duk_has_prop(ctx, i_mappednames)) {
-+				/* steps 11.c.ii.1 - 11.c.ii.4, but our internal book-keeping
-+				 * differs from the reference model
-+				 */
-+
-+				/* [... name] */
-+
-+				need_map = 1;
-+
-+				DUK_DDD(DUK_DDDPRINT("set mappednames[%s]=%ld",
-+				                     (const char *) duk_get_string(ctx, -1),
-+				                     (long) idx));
-+				duk_dup(ctx, -1);                      /* name */
-+				duk_push_uint(ctx, (duk_uint_t) idx);  /* index */
-+				duk_to_string(ctx, -1);
-+				duk_xdef_prop_wec(ctx, i_mappednames);  /* out of spec, must be configurable */
-+
-+				DUK_DDD(DUK_DDDPRINT("set map[%ld]=%s",
-+				                     (long) idx,
-+				                     duk_get_string(ctx, -1)));
-+				duk_dup(ctx, -1);         /* name */
-+				duk_xdef_prop_index_wec(ctx, i_map, (duk_uarridx_t) idx);  /* out of spec, must be configurable */
-+			} else {
-+				/* duk_has_prop() popped the second 'name' */
-+			}
-+
-+			/* [... name] */
-+			duk_pop(ctx);  /* pop 'name' */
-+		}
-+
-+		idx--;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("actual arguments processed"));
-+
-+	/* step 12 */
-+	if (need_map) {
-+		DUK_DDD(DUK_DDDPRINT("adding 'map' and 'varenv' to arguments object"));
-+
-+		/* should never happen for a strict callee */
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(func));
-+
-+		duk_dup(ctx, i_map);
-+		duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_INT_MAP, DUK_PROPDESC_FLAGS_NONE);  /* out of spec, don't care */
-+
-+		/* The variable environment for magic variable bindings needs to be
-+		 * given by the caller and recorded in the arguments object.
-+		 *
-+		 * See E5 Section 10.6, the creation of setters/getters.
-+		 *
-+		 * The variable environment also provides access to the callee, so
-+		 * an explicit (internal) callee property is not needed.
-+		 */
-+
-+		duk_push_hobject(ctx, varenv);
-+		duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_INT_VARENV, DUK_PROPDESC_FLAGS_NONE);  /* out of spec, don't care */
-+	}
-+
-+	/* steps 13-14 */
-+	if (DUK_HOBJECT_HAS_STRICT(func)) {
-+		/*
-+		 *  Note: callee/caller are throwers and are not deletable etc.
-+		 *  They could be implemented as virtual properties, but currently
-+		 *  there is no support for virtual properties which are accessors
-+		 *  (only plain virtual properties).  This would not be difficult
-+		 *  to change in duk_hobject_props, but we can make the throwers
-+		 *  normal, concrete properties just as easily.
-+		 *
-+		 *  Note that the specification requires that the *same* thrower
-+		 *  built-in object is used here!  See E5 Section 10.6 main
-+		 *  algoritm, step 14, and Section 13.2.3 which describes the
-+		 *  thrower.  See test case test-arguments-throwers.js.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("strict function, setting caller/callee to throwers"));
-+
-+		duk_xdef_prop_stridx_thrower(ctx, i_arg, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
-+		duk_xdef_prop_stridx_thrower(ctx, i_arg, DUK_STRIDX_CALLEE, DUK_PROPDESC_FLAGS_NONE);
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("non-strict function, setting callee to actual value"));
-+		duk_push_hobject(ctx, func);
-+		duk_xdef_prop_stridx(ctx, i_arg, DUK_STRIDX_CALLEE, DUK_PROPDESC_FLAGS_WC);
-+	}
-+
-+	/* set exotic behavior only after we're done */
-+	if (need_map) {
-+		/*
-+		 *  Note: exotic behaviors are only enabled for arguments
-+		 *  objects which have a parameter map (see E5 Section 10.6
-+		 *  main algorithm, step 12).
-+		 *
-+		 *  In particular, a non-strict arguments object with no
-+		 *  mapped formals does *NOT* get exotic behavior, even
-+		 *  for e.g. "caller" property.  This seems counterintuitive
-+		 *  but seems to be the case.
-+		 */
-+
-+		/* cannot be strict (never mapped variables) */
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(func));
-+
-+		DUK_DDD(DUK_DDDPRINT("enabling exotic behavior for arguments object"));
-+		DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(arg);
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("not enabling exotic behavior for arguments object"));
-+	}
-+
-+	/* nice log */
-+	DUK_DDD(DUK_DDDPRINT("final arguments related objects: "
-+	                     "arguments at index %ld -> %!O "
-+	                     "map at index %ld -> %!O "
-+	                     "mappednames at index %ld -> %!O",
-+	                     (long) i_arg, (duk_heaphdr *) duk_get_hobject(ctx, i_arg),
-+	                     (long) i_map, (duk_heaphdr *) duk_get_hobject(ctx, i_map),
-+	                     (long) i_mappednames, (duk_heaphdr *) duk_get_hobject(ctx, i_mappednames)));
-+
-+	/* [args(n) [crud] formals arguments map mappednames] -> [args [crud] arguments] */
-+	duk_pop_2(ctx);
-+	duk_remove(ctx, -2);
-+}
-+
-+/* Helper for creating the arguments object and adding it to the env record
-+ * on top of the value stack.  This helper has a very strict dependency on
-+ * the shape of the input stack.
-+ */
-+DUK_LOCAL
-+void duk__handle_createargs_for_call(duk_hthread *thr,
-+                                     duk_hobject *func,
-+                                     duk_hobject *env,
-+                                     duk_idx_t num_stack_args) {
-+	duk_context *ctx = (duk_context *) thr;
-+
-+	DUK_DDD(DUK_DDDPRINT("creating arguments object for function call"));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(env != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func));
-+	DUK_ASSERT(duk_get_top(ctx) >= num_stack_args + 1);
-+
-+	/* [... arg1 ... argN envobj] */
-+
-+	duk__create_arguments_object(thr,
-+	                             func,
-+	                             env,
-+	                             duk_get_top(ctx) - num_stack_args - 1,    /* idx_argbase */
-+	                             num_stack_args);
-+
-+	/* [... arg1 ... argN envobj argobj] */
-+
-+	duk_xdef_prop_stridx(ctx,
-+	                     -2,
-+	                     DUK_STRIDX_LC_ARGUMENTS,
-+	                     DUK_HOBJECT_HAS_STRICT(func) ? DUK_PROPDESC_FLAGS_E :   /* strict: non-deletable, non-writable */
-+	                                                    DUK_PROPDESC_FLAGS_WE);  /* non-strict: non-deletable, writable */
-+	/* [... arg1 ... argN envobj] */
-+}
-+
-+/*
-+ *  Helper for handling a "bound function" chain when a call is being made.
-+ *
-+ *  Follows the bound function chain until a non-bound function is found.
-+ *  Prepends the bound arguments to the value stack (at idx_func + 2),
-+ *  updating 'num_stack_args' in the process.  The 'this' binding is also
-+ *  updated if necessary (at idx_func + 1).  Note that for constructor calls
-+ *  the 'this' binding is never updated by [[BoundThis]].
-+ *
-+ *  XXX: bound function chains could be collapsed at bound function creation
-+ *  time so that each bound function would point directly to a non-bound
-+ *  function.  This would make call time handling much easier.
-+ */
-+
-+DUK_LOCAL
-+void duk__handle_bound_chain_for_call(duk_hthread *thr,
-+                                      duk_idx_t idx_func,
-+                                      duk_idx_t *p_num_stack_args,   /* may be changed by call */
-+                                      duk_bool_t is_constructor_call) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_idx_t num_stack_args;
-+	duk_tval *tv_func;
-+	duk_hobject *func;
-+	duk_uint_t sanity;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(p_num_stack_args != NULL);
-+
-+	/* On entry, item at idx_func is a bound, non-lightweight function,
-+	 * but we don't rely on that below.
-+	 */
-+
-+	num_stack_args = *p_num_stack_args;
-+
-+	sanity = DUK_HOBJECT_BOUND_CHAIN_SANITY;
-+	do {
-+		duk_idx_t i, len;
-+
-+		tv_func = duk_require_tval(ctx, idx_func);
-+		DUK_ASSERT(tv_func != NULL);
-+
-+		if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
-+			/* Lightweight function: never bound, so terminate. */
-+			break;
-+		} else if (DUK_TVAL_IS_OBJECT(tv_func)) {
-+			func = DUK_TVAL_GET_OBJECT(tv_func);
-+			if (!DUK_HOBJECT_HAS_BOUND(func)) {
-+				/* Normal non-bound function. */
-+				break;
-+			}
-+		} else {
-+			/* Function.prototype.bind() should never let this happen,
-+			 * ugly error message is enough.
-+			 */
-+			DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR);
-+		}
-+		DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv_func) != NULL);
-+
-+		/* XXX: this could be more compact by accessing the internal properties
-+		 * directly as own properties (they cannot be inherited, and are not
-+		 * externally visible).
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("bound function encountered, ptr=%p, num_stack_args=%ld: %!T",
-+		                     (void *) DUK_TVAL_GET_OBJECT(tv_func), (long) num_stack_args, tv_func));
-+
-+		/* [ ... func this arg1 ... argN ] */
-+
-+		if (is_constructor_call) {
-+			/* See: ecmascript-testcases/test-spec-bound-constructor.js */
-+			DUK_DDD(DUK_DDDPRINT("constructor call: don't update this binding"));
-+		} else {
-+			duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_THIS);
-+			duk_replace(ctx, idx_func + 1);  /* idx_this = idx_func + 1 */
-+		}
-+
-+		/* [ ... func this arg1 ... argN ] */
-+
-+		/* XXX: duk_get_length? */
-+		duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_ARGS);  /* -> [ ... func this arg1 ... argN _Args ] */
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH);          /* -> [ ... func this arg1 ... argN _Args length ] */
-+		len = (duk_idx_t) duk_require_int(ctx, -1);
-+		duk_pop(ctx);
-+		for (i = 0; i < len; i++) {
-+			/* XXX: very slow - better to bulk allocate a gap, and copy
-+			 * from args_array directly (we know it has a compact array
-+			 * part, etc).
-+			 */
-+
-+			/* [ ... func this <some bound args> arg1 ... argN _Args ] */
-+			duk_get_prop_index(ctx, -1, i);
-+			duk_insert(ctx, idx_func + 2 + i);  /* idx_args = idx_func + 2 */
-+		}
-+		num_stack_args += len;  /* must be updated to work properly (e.g. creation of 'arguments') */
-+		duk_pop(ctx);
-+
-+		/* [ ... func this <bound args> arg1 ... argN ] */
-+
-+		duk_get_prop_stridx(ctx, idx_func, DUK_STRIDX_INT_TARGET);
-+		duk_replace(ctx, idx_func);  /* replace in stack */
-+
-+		DUK_DDD(DUK_DDDPRINT("bound function handled, num_stack_args=%ld, idx_func=%ld, curr func=%!T",
-+		                     (long) num_stack_args, (long) idx_func, duk_get_tval(ctx, idx_func)));
-+	} while (--sanity > 0);
-+
-+	if (sanity == 0) {
-+		DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_BOUND_CHAIN_LIMIT);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("final non-bound function is: %!T", duk_get_tval(ctx, idx_func)));
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	tv_func = duk_require_tval(ctx, idx_func);
-+	DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv_func) || DUK_TVAL_IS_OBJECT(tv_func));
-+	if (DUK_TVAL_IS_OBJECT(tv_func)) {
-+		func = DUK_TVAL_GET_OBJECT(tv_func);
-+		DUK_ASSERT(func != NULL);
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
-+		DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func) ||
-+		           DUK_HOBJECT_HAS_NATIVEFUNCTION(func));
-+	}
-+#endif
-+
-+	/* write back */
-+	*p_num_stack_args = num_stack_args;
-+}
-+
-+/*
-+ *  Helper for setting up var_env and lex_env of an activation,
-+ *  assuming it does NOT have the DUK_HOBJECT_FLAG_NEWENV flag.
-+ */
-+
-+DUK_LOCAL
-+void duk__handle_oldenv_for_call(duk_hthread *thr,
-+                                 duk_hobject *func,
-+                                 duk_activation *act) {
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(act != NULL);
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV(func));
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(func));
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr));
-+	if (tv) {
-+		DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+		DUK_ASSERT(DUK_HOBJECT_IS_ENV(DUK_TVAL_GET_OBJECT(tv)));
-+		act->lex_env = DUK_TVAL_GET_OBJECT(tv);
-+
-+		tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_VARENV(thr));
-+		if (tv) {
-+			DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+			DUK_ASSERT(DUK_HOBJECT_IS_ENV(DUK_TVAL_GET_OBJECT(tv)));
-+			act->var_env = DUK_TVAL_GET_OBJECT(tv);
-+		} else {
-+			act->var_env = act->lex_env;
-+		}
-+	} else {
-+		act->lex_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+		act->var_env = act->lex_env;
-+	}
-+
-+	DUK_HOBJECT_INCREF_ALLOWNULL(thr, act->lex_env);
-+	DUK_HOBJECT_INCREF_ALLOWNULL(thr, act->var_env);
-+}
-+
-+/*
-+ *  Helper for updating callee 'caller' property.
-+ */
-+
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+DUK_LOCAL void duk__update_func_caller_prop(duk_hthread *thr, duk_hobject *func) {
-+	duk_tval *tv_caller;
-+	duk_hobject *h_tmp;
-+	duk_activation *act_callee;
-+	duk_activation *act_caller;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));  /* bound chain resolved */
-+	DUK_ASSERT(thr->callstack_top >= 1);
-+
-+	if (DUK_HOBJECT_HAS_STRICT(func)) {
-+		/* Strict functions don't get their 'caller' updated. */
-+		return;
-+	}
-+
-+	act_callee = thr->callstack + thr->callstack_top - 1;
-+	act_caller = (thr->callstack_top >= 2 ? act_callee - 1 : NULL);
-+
-+	/* Backup 'caller' property and update its value. */
-+	tv_caller = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_CALLER(thr));
-+	if (tv_caller) {
-+		/* If caller is global/eval code, 'caller' should be set to
-+		 * 'null'.
-+		 *
-+		 * XXX: there is no exotic flag to infer this correctly now.
-+		 * The NEWENV flag is used now which works as intended for
-+		 * everything (global code, non-strict eval code, and functions)
-+		 * except strict eval code.  Bound functions are never an issue
-+		 * because 'func' has been resolved to a non-bound function.
-+		 */
-+
-+		if (act_caller) {
-+			/* act_caller->func may be NULL in some finalization cases,
-+			 * just treat like we don't know the caller.
-+			 */
-+			if (act_caller->func && !DUK_HOBJECT_HAS_NEWENV(act_caller->func)) {
-+				/* Setting to NULL causes 'caller' to be set to
-+				 * 'null' as desired.
-+				 */
-+				act_caller = NULL;
-+			}
-+		}
-+
-+		if (DUK_TVAL_IS_OBJECT(tv_caller)) {
-+			h_tmp = DUK_TVAL_GET_OBJECT(tv_caller);
-+			DUK_ASSERT(h_tmp != NULL);
-+			act_callee->prev_caller = h_tmp;
-+
-+			/* Previous value doesn't need refcount changes because its ownership
-+			 * is transferred to prev_caller.
-+			 */
-+
-+			if (act_caller) {
-+				DUK_ASSERT(act_caller->func != NULL);
-+				DUK_TVAL_SET_OBJECT(tv_caller, act_caller->func);
-+				DUK_TVAL_INCREF(thr, tv_caller);
-+			} else {
-+				DUK_TVAL_SET_NULL(tv_caller);  /* no incref */
-+			}
-+		} else {
-+			/* 'caller' must only take on 'null' or function value */
-+			DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_caller));
-+			DUK_ASSERT(act_callee->prev_caller == NULL);
-+			if (act_caller && act_caller->func) {
-+				/* Tolerate act_caller->func == NULL which happens in
-+				 * some finalization cases; treat like unknown caller.
-+				 */
-+				DUK_TVAL_SET_OBJECT(tv_caller, act_caller->func);
-+				DUK_TVAL_INCREF(thr, tv_caller);
-+			} else {
-+				DUK_TVAL_SET_NULL(tv_caller);  /* no incref */
-+			}
-+		}
-+	}
-+}
-+#endif  /* DUK_USE_NONSTD_FUNC_CALLER_PROPERTY */
-+
-+/*
-+ *  Determine the effective 'this' binding and coerce the current value
-+ *  on the valstack to the effective one (in-place, at idx_this).
-+ *
-+ *  The current this value in the valstack (at idx_this) represents either:
-+ *    - the caller's requested 'this' binding; or
-+ *    - a 'this' binding accumulated from the bound function chain
-+ *
-+ *  The final 'this' binding for the target function may still be
-+ *  different, and is determined as described in E5 Section 10.4.3.
-+ *
-+ *  For global and eval code (E5 Sections 10.4.1 and 10.4.2), we assume
-+ *  that the caller has provided the correct 'this' binding explicitly
-+ *  when calling, i.e.:
-+ *
-+ *    - global code: this=global object
-+ *    - direct eval: this=copy from eval() caller's this binding
-+ *    - other eval:  this=global object
-+ *
-+ *  Note: this function may cause a recursive function call with arbitrary
-+ *  side effects, because ToObject() may be called.
-+ */
-+
-+DUK_LOCAL
-+void duk__coerce_effective_this_binding(duk_hthread *thr,
-+                                        duk_hobject *func,
-+                                        duk_idx_t idx_this) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_small_int_t strict;
-+
-+	if (func) {
-+		strict = DUK_HOBJECT_HAS_STRICT(func);
-+	} else {
-+		/* Lightfuncs are always considered strict. */
-+		strict = 1;
-+	}
-+
-+	if (strict) {
-+		DUK_DDD(DUK_DDDPRINT("this binding: strict -> use directly"));
-+	} else {
-+		duk_tval *tv_this = duk_require_tval(ctx, idx_this);
-+		duk_hobject *obj_global;
-+
-+		if (DUK_TVAL_IS_OBJECT(tv_this)) {
-+			DUK_DDD(DUK_DDDPRINT("this binding: non-strict, object -> use directly"));
-+		} else if (DUK_TVAL_IS_LIGHTFUNC(tv_this)) {
-+			/* Lightfuncs are treated like objects and not coerced. */
-+			DUK_DDD(DUK_DDDPRINT("this binding: non-strict, lightfunc -> use directly"));
-+		} else if (DUK_TVAL_IS_UNDEFINED(tv_this) || DUK_TVAL_IS_NULL(tv_this)) {
-+			DUK_DDD(DUK_DDDPRINT("this binding: non-strict, undefined/null -> use global object"));
-+			obj_global = thr->builtins[DUK_BIDX_GLOBAL];
-+			if (obj_global) {
-+				duk_push_hobject(ctx, obj_global);
-+			} else {
-+				/*
-+				 *  This may only happen if built-ins are being "torn down".
-+				 *  This behavior is out of specification scope.
-+				 */
-+				DUK_D(DUK_DPRINT("this binding: wanted to use global object, but it is NULL -> using undefined instead"));
-+				duk_push_undefined(ctx);
-+			}
-+			duk_replace(ctx, idx_this);
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("this binding: non-strict, not object/undefined/null -> use ToObject(value)"));
-+			duk_to_object(ctx, idx_this);  /* may have side effects */
-+		}
-+	}
-+}
-+
-+/*
-+ *  Shared helper for non-bound func lookup.
-+ *
-+ *  Returns duk_hobject * to the final non-bound function (NULL for lightfunc).
-+ */
-+
-+DUK_LOCAL
-+duk_hobject *duk__nonbound_func_lookup(duk_context *ctx,
-+                                       duk_idx_t idx_func,
-+                                       duk_idx_t *out_num_stack_args,
-+                                       duk_tval **out_tv_func,
-+                                       duk_small_uint_t call_flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_tval *tv_func;
-+	duk_hobject *func;
-+
-+	for (;;) {
-+		/* Use loop to minimize code size of relookup after bound function case */
-+		tv_func = duk_get_tval(ctx, idx_func);
-+		DUK_ASSERT(tv_func != NULL);
-+
-+		if (DUK_TVAL_IS_OBJECT(tv_func)) {
-+			func = DUK_TVAL_GET_OBJECT(tv_func);
-+			if (!DUK_HOBJECT_IS_CALLABLE(func)) {
-+				goto not_callable_error;
-+			}
-+			if (DUK_HOBJECT_HAS_BOUND(func)) {
-+				duk__handle_bound_chain_for_call(thr, idx_func, out_num_stack_args, call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL);
-+
-+				/* The final object may be a normal function or a lightfunc.
-+				 * We need to re-lookup tv_func because it may have changed
-+				 * (also value stack may have been resized).  Loop again to
-+				 * do that; we're guaranteed not to come here again.
-+				 */
-+				DUK_ASSERT(DUK_TVAL_IS_OBJECT(duk_require_tval(ctx, idx_func)) ||
-+				           DUK_TVAL_IS_LIGHTFUNC(duk_require_tval(ctx, idx_func)));
-+				continue;
-+			}
-+		} else if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
-+			func = NULL;
-+		} else {
-+			goto not_callable_error;
-+		}
-+		break;
-+	}
-+
-+	DUK_ASSERT((DUK_TVAL_IS_OBJECT(tv_func) && DUK_HOBJECT_IS_CALLABLE(DUK_TVAL_GET_OBJECT(tv_func))) ||
-+	           DUK_TVAL_IS_LIGHTFUNC(tv_func));
-+	DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));
-+	DUK_ASSERT(func == NULL || (DUK_HOBJECT_IS_COMPILEDFUNCTION(func) ||
-+	                            DUK_HOBJECT_IS_NATIVEFUNCTION(func)));
-+
-+	*out_tv_func = tv_func;
-+	return func;
-+
-+ not_callable_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE);
-+	DUK_UNREACHABLE();
-+	return NULL;  /* never executed */
-+}
-+
-+/*
-+ *  Value stack resize and stack top adjustment helper
-+ *
-+ *  XXX: This should all be merged to duk_valstack_resize_raw().
-+ */
-+
-+DUK_LOCAL
-+void duk__adjust_valstack_and_top(duk_hthread *thr, duk_idx_t num_stack_args, duk_idx_t idx_args, duk_idx_t nregs, duk_idx_t nargs, duk_hobject *func) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_size_t vs_min_size;
-+	duk_bool_t adjusted_top = 0;
-+
-+	vs_min_size = (thr->valstack_bottom - thr->valstack) +         /* bottom of current func */
-+	              idx_args;                                        /* bottom of new func */
-+
-+	if (nregs >= 0) {
-+		DUK_ASSERT(nargs >= 0);
-+		DUK_ASSERT(nregs >= nargs);
-+		vs_min_size += nregs;
-+	} else {
-+		/* 'func' wants stack "as is" */
-+		vs_min_size += num_stack_args;  /* num entries of new func at entry */
-+	}
-+	if (func == NULL || DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
-+		vs_min_size += DUK_VALSTACK_API_ENTRY_MINIMUM;         /* Duktape/C API guaranteed entries (on top of args) */
-+	}
-+	vs_min_size += DUK_VALSTACK_INTERNAL_EXTRA;                    /* + spare */
-+
-+	/* XXX: Awkward fix for GH-107: we can't resize the value stack to
-+	 * a size smaller than the current top, so the order of the resize
-+	 * and adjusting the stack top depends on the current vs. final size
-+	 * of the value stack.  Ideally duk_valstack_resize_raw() would have
-+	 * a combined algorithm to avoid this.
-+	 */
-+
-+	if (vs_min_size < (duk_size_t) (thr->valstack_top  - thr->valstack)) {
-+		DUK_DDD(DUK_DDDPRINT(("final size smaller, set top before resize")));
-+
-+		DUK_ASSERT(nregs >= 0);  /* can't happen when keeping current stack size */
-+		duk_set_top(ctx, idx_args + nargs);  /* clamp anything above nargs */
-+		duk_set_top(ctx, idx_args + nregs);  /* extend with undefined */
-+		adjusted_top = 1;
-+	}
-+
-+	(void) duk_valstack_resize_raw((duk_context *) thr,
-+	                               vs_min_size,
-+	                               DUK_VSRESIZE_FLAG_SHRINK |      /* flags */
-+	                               0 /* no compact */ |
-+	                               DUK_VSRESIZE_FLAG_THROW);
-+
-+	if (!adjusted_top) {
-+		if (nregs >= 0) {
-+			DUK_ASSERT(nregs >= nargs);
-+			duk_set_top(ctx, idx_args + nargs);  /* clamp anything above nargs */
-+			duk_set_top(ctx, idx_args + nregs);  /* extend with undefined */
-+		}
-+	}
-+}
-+
-+/*
-+ *  Helper for making various kinds of calls.
-+ *
-+ *  Call flags:
-+ *
-+ *    DUK_CALL_FLAG_PROTECTED        <-->  protected call
-+ *    DUK_CALL_FLAG_IGNORE_RECLIMIT  <-->  ignore C recursion limit,
-+ *                                         for errhandler calls
-+ *    DUK_CALL_FLAG_CONSTRUCTOR_CALL <-->  for 'new Foo()' calls
-+ *
-+ *  Input stack:
-+ *
-+ *    [ func this arg1 ... argN ]
-+ *
-+ *  Output stack:
-+ *
-+ *    [ retval ]         (DUK_EXEC_SUCCESS)
-+ *    [ errobj ]         (DUK_EXEC_ERROR (normal error), protected call)
-+ *
-+ *  Even when executing a protected call an error may be thrown in rare cases.
-+ *  For instance, if we run out of memory when setting up the return stack
-+ *  after a caught error, the out of memory is propagated to the caller.
-+ *  Similarly, API errors (such as invalid input stack shape and invalid
-+ *  indices) cause an error to propagate out of this function.  If there is
-+ *  no catchpoint for this error, the fatal error handler is called.
-+ *
-+ *  See 'execution.txt'.
-+ *
-+ *  The allowed thread states for making a call are:
-+ *    - thr matches heap->curr_thread, and thr is already RUNNING
-+ *    - thr does not match heap->curr_thread (may be NULL or other),
-+ *      and thr is INACTIVE (in this case, a setjmp() catchpoint is
-+ *      always used for thread book-keeping to work properly)
-+ *
-+ *  Like elsewhere, gotos are used to keep indent level minimal and
-+ *  avoiding a dozen helpers with awkward plumbing.
-+ *
-+ *  Note: setjmp() and local variables have a nasty interaction,
-+ *  see execution.txt; non-volatile locals modified after setjmp()
-+ *  call are not guaranteed to keep their value.
-+ */
-+
-+DUK_INTERNAL
-+duk_int_t duk_handle_call(duk_hthread *thr,
-+                          duk_idx_t num_stack_args,
-+                          duk_small_uint_t call_flags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_size_t entry_valstack_bottom_index;
-+	duk_size_t entry_valstack_end;
-+	duk_size_t entry_callstack_top;
-+	duk_size_t entry_catchstack_top;
-+	duk_int_t entry_call_recursion_depth;
-+	duk_hthread *entry_curr_thread;
-+	duk_uint_fast8_t entry_thread_state;
-+	volatile duk_bool_t need_setjmp;
-+	duk_jmpbuf * volatile old_jmpbuf_ptr = NULL;    /* ptr is volatile (not the target) */
-+	duk_idx_t idx_func;         /* valstack index of 'func' and retval (relative to entry valstack_bottom) */
-+	duk_idx_t idx_args;         /* valstack index of start of args (arg1) (relative to entry valstack_bottom) */
-+	duk_idx_t nargs;            /* # argument registers target function wants (< 0 => "as is") */
-+	duk_idx_t nregs;            /* # total registers target function wants on entry (< 0 => "as is") */
-+	duk_hobject *func;          /* 'func' on stack (borrowed reference) */
-+	duk_tval *tv_func;          /* duk_tval ptr for 'func' on stack (borrowed reference) or tv_func_copy */
-+	duk_tval tv_func_copy;      /* to avoid relookups */
-+	duk_activation *act;
-+	duk_hobject *env;
-+	duk_jmpbuf our_jmpbuf;
-+	duk_tval tv_tmp;
-+	duk_int_t retval = DUK_EXEC_ERROR;
-+	duk_ret_t rc;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(num_stack_args >= 0);
-+
-+	/* XXX: currently NULL allocations are not supported; remove if later allowed */
-+	DUK_ASSERT(thr->valstack != NULL);
-+	DUK_ASSERT(thr->callstack != NULL);
-+	DUK_ASSERT(thr->catchstack != NULL);
-+
-+	/*
-+	 *  Preliminaries, required by setjmp() handler.
-+	 *
-+	 *  Must be careful not to throw an unintended error here.
-+	 *
-+	 *  Note: careful with indices like '-x'; if 'x' is zero, it
-+	 *  refers to valstack_bottom.
-+	 */
-+
-+	entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
-+	entry_valstack_end = (duk_size_t) (thr->valstack_end - thr->valstack);
-+	entry_callstack_top = thr->callstack_top;
-+	entry_catchstack_top = thr->catchstack_top;
-+	entry_call_recursion_depth = thr->heap->call_recursion_depth;
-+	entry_curr_thread = thr->heap->curr_thread;  /* Note: may be NULL if first call */
-+	entry_thread_state = thr->state;
-+	idx_func = duk_normalize_index(ctx, -num_stack_args - 2);  /* idx_func must be valid, note: non-throwing! */
-+	idx_args = idx_func + 2;                                   /* idx_args is not necessarily valid if num_stack_args == 0 (idx_args then equals top) */
-+
-+	/* Need a setjmp() catchpoint if a protected call OR if we need to
-+	 * do mandatory cleanup.
-+	 */
-+	need_setjmp = ((call_flags & DUK_CALL_FLAG_PROTECTED) != 0) || (thr->heap->curr_thread != thr);
-+
-+	DUK_DD(DUK_DDPRINT("duk_handle_call: thr=%p, num_stack_args=%ld, "
-+	                   "call_flags=0x%08lx (protected=%ld, ignorerec=%ld, constructor=%ld), need_setjmp=%ld, "
-+	                   "valstack_top=%ld, idx_func=%ld, idx_args=%ld, rec_depth=%ld/%ld, "
-+	                   "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, "
-+	                   "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld",
-+	                   (void *) thr,
-+	                   (long) num_stack_args,
-+	                   (unsigned long) call_flags,
-+	                   (long) ((call_flags & DUK_CALL_FLAG_PROTECTED) != 0 ? 1 : 0),
-+	                   (long) ((call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) != 0 ? 1 : 0),
-+	                   (long) ((call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) != 0 ? 1 : 0),
-+	                   (long) need_setjmp,
-+	                   (long) duk_get_top(ctx),
-+	                   (long) idx_func,
-+	                   (long) idx_args,
-+	                   (long) thr->heap->call_recursion_depth,
-+	                   (long) thr->heap->call_recursion_limit,
-+	                   (long) entry_valstack_bottom_index,
-+	                   (long) entry_callstack_top,
-+	                   (long) entry_catchstack_top,
-+	                   (long) entry_call_recursion_depth,
-+	                   (void *) entry_curr_thread,
-+	                   (long) entry_thread_state));
-+
-+	/* XXX: Multiple tv_func lookups are now avoided by making a local
-+	 * copy of tv_func.  Another approach would be to compute an offset
-+	 * for tv_func from valstack bottom and recomputing the tv_func
-+	 * pointer quickly as valstack + offset instead of calling duk_get_tval().
-+	 */
-+
-+	if (idx_func < 0 || idx_args < 0) {
-+		/*
-+		 *  Since stack indices are not reliable, we can't do anything useful
-+		 *  here.  Invoke the existing setjmp catcher, or if it doesn't exist,
-+		 *  call the fatal error handler.
-+		 */
-+
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+	}
-+
-+	/*
-+	 *  Setup a setjmp() catchpoint first because even the call setup
-+	 *  may fail.
-+	 */
-+
-+	if (!need_setjmp) {
-+		DUK_DDD(DUK_DDDPRINT("don't need a setjmp catchpoint"));
-+		goto handle_call;
-+	}
-+
-+	old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr;
-+	thr->heap->lj.jmpbuf_ptr = &our_jmpbuf;
-+
-+	if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb) == 0) {
-+		DUK_DDD(DUK_DDDPRINT("setjmp catchpoint setup complete"));
-+		goto handle_call;
-+	}
-+
-+	/*
-+	 *  Error during setup, call, or postprocessing of the call.
-+	 *  The error value is in heap->lj.value1.
-+	 *
-+	 *  Note: any local variables accessed here must have their value
-+	 *  assigned *before* the setjmp() call, OR they must be declared
-+	 *  volatile.  Otherwise their value is not guaranteed to be correct.
-+	 *
-+	 *  The following are such variables:
-+	 *    - duk_handle_call() parameters
-+	 *    - entry_*
-+	 *    - idx_func
-+	 *    - idx_args
-+	 *
-+	 *  The very first thing we do is restore the previous setjmp catcher.
-+	 *  This means that any error in error handling will propagate outwards
-+	 *  instead of causing a setjmp() re-entry above.  The *only* actual
-+	 *  errors that should happen here are allocation errors.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_call(): %!T",
-+	                     (duk_tval *) &thr->heap->lj.value1));
-+
-+	DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW);
-+	DUK_ASSERT(thr->callstack_top >= entry_callstack_top);
-+	DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);
-+
-+	/*
-+	 *  Restore previous setjmp catchpoint
-+	 */
-+
-+	/* Note: either pointer may be NULL (at entry), so don't assert */
-+	DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p",
-+	                     (void *) (thr && thr->heap ? thr->heap->lj.jmpbuf_ptr : NULL),
-+	                     (void *) old_jmpbuf_ptr));
-+
-+	thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
-+
-+	if (!(call_flags & DUK_CALL_FLAG_PROTECTED)) {
-+		/*
-+		 *  Caller did not request a protected call but a setjmp
-+		 *  catchpoint was set up to allow cleanup.  So, clean up
-+		 *  and rethrow.
-+		 *
-+		 *  We must restore curr_thread here to ensure that its
-+		 *  current value doesn't end up pointing to a thread object
-+		 *  which has been freed.  This is now a problem because some
-+		 *  call sites (namely duk_safe_call()) *first* unwind stacks
-+		 *  and only then deal with curr_thread.  If those call sites
-+		 *  were fixed, this wouldn't matter here.
-+		 *
-+		 *  Note: this case happens e.g. when heap->curr_thread is
-+		 *  NULL on entry.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("call is not protected -> clean up and rethrow"));
-+
-+		DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread);  /* may be NULL */
-+		thr->state = entry_thread_state;
-+		DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) ||  /* first call */
-+		           (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) ||  /* other call */
-+		           (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr));     /* current thread */
-+
-+		/* XXX: should setjmp catcher be responsible for this instead? */
-+		thr->heap->call_recursion_depth = entry_call_recursion_depth;
-+		duk_err_longjmp(thr);
-+		DUK_UNREACHABLE();
-+	}
-+
-+	duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
-+	duk_hthread_callstack_unwind(thr, entry_callstack_top);
-+	thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
-+
-+	/* [ ... func this (crud) errobj ] */
-+
-+	/* XXX: is there space?  better implementation: write directly over
-+	 * 'func' slot to avoid valstack grow issues.
-+	 */
-+	duk_push_tval(ctx, &thr->heap->lj.value1);
-+
-+	/* [ ... func this (crud) errobj ] */
-+
-+	duk_replace(ctx, idx_func);
-+	duk_set_top(ctx, idx_func + 1);
-+
-+	/* [ ... errobj ] */
-+
-+	/* Ensure there is internal valstack spare before we exit; this may
-+	 * throw an alloc error.  The same guaranteed size must be available
-+	 * as before the call.  This is not optimal now: we store the valstack
-+	 * allocated size during entry; this value may be higher than the
-+	 * minimal guarantee for an application.
-+	 */
-+
-+	(void) duk_valstack_resize_raw((duk_context *) thr,
-+	                               entry_valstack_end,                    /* same as during entry */
-+	                               DUK_VSRESIZE_FLAG_SHRINK |             /* flags */
-+	                               DUK_VSRESIZE_FLAG_COMPACT |
-+	                               DUK_VSRESIZE_FLAG_THROW);
-+
-+	/* Note: currently a second setjmp restoration is done at the target;
-+	 * this is OK, but could be refactored away.
-+	 */
-+	retval = DUK_EXEC_ERROR;
-+	goto shrink_and_finished;
-+
-+ handle_call:
-+	/*
-+	 *  Thread state check and book-keeping.
-+	 */
-+
-+	if (thr == thr->heap->curr_thread) {
-+		/* same thread */
-+		if (thr->state != DUK_HTHREAD_STATE_RUNNING) {
-+			/* should actually never happen, but check anyway */
-+			goto thread_state_error;
-+		}
-+	} else {
-+		/* different thread */
-+		DUK_ASSERT(thr->heap->curr_thread == NULL ||
-+		           thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING);
-+		if (thr->state != DUK_HTHREAD_STATE_INACTIVE) {
-+			goto thread_state_error;
-+		}
-+		DUK_HEAP_SWITCH_THREAD(thr->heap, thr);
-+		thr->state = DUK_HTHREAD_STATE_RUNNING;
-+
-+		/* Note: multiple threads may be simultaneously in the RUNNING
-+		 * state, but not in the same "resume chain".
-+		 */
-+	}
-+
-+	DUK_ASSERT(thr->heap->curr_thread == thr);
-+	DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
-+
-+	/*
-+	 *  C call recursion depth check, which provides a reasonable upper
-+	 *  bound on maximum C stack size (arbitrary C stack growth is only
-+	 *  possible by recursive handle_call / handle_safe_call calls).
-+	 */
-+
-+	DUK_ASSERT(thr->heap->call_recursion_depth >= 0);
-+	DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit);
-+
-+	if (call_flags & DUK_CALL_FLAG_IGNORE_RECLIMIT) {
-+		DUK_DD(DUK_DDPRINT("ignoring reclimit for this call (probably an errhandler call)"));
-+	} else {
-+		if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) {
-+			/* XXX: error message is a bit misleading: we reached a recursion
-+			 * limit which is also essentially the same as a C callstack limit
-+			 * (except perhaps with some relaxed threading assumptions).
-+			 */
-+			DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_C_CALLSTACK_LIMIT);
-+		}
-+		thr->heap->call_recursion_depth++;
-+	}
-+
-+	/*
-+	 *  Check the function type, handle bound function chains, and prepare
-+	 *  parameters for the rest of the call handling.  Also figure out the
-+	 *  effective 'this' binding, which replaces the current value at
-+	 *  idx_func + 1.
-+	 *
-+	 *  If the target function is a 'bound' one, follow the chain of 'bound'
-+	 *  functions until a non-bound function is found.  During this process,
-+	 *  bound arguments are 'prepended' to existing ones, and the "this"
-+	 *  binding is overridden.  See E5 Section 15.3.4.5.1.
-+	 *
-+	 *  Lightfunc detection happens here too.  Note that lightweight functions
-+	 *  can be wrapped by (non-lightweight) bound functions so we must resolve
-+	 *  the bound function chain first.
-+	 */
-+
-+	func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags);
-+	DUK_TVAL_SET_TVAL(&tv_func_copy, tv_func);
-+	tv_func = &tv_func_copy;  /* local copy to avoid relookups */
-+
-+	DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));
-+	DUK_ASSERT(func == NULL || (DUK_HOBJECT_IS_COMPILEDFUNCTION(func) ||
-+	                            DUK_HOBJECT_IS_NATIVEFUNCTION(func)));
-+
-+	duk__coerce_effective_this_binding(thr, func, idx_func + 1);
-+	DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, idx_func + 1)));
-+
-+	/* These base values are never used, but if the compiler doesn't know
-+	 * that DUK_ERROR() won't return, these are needed to silence warnings.
-+	 * On the other hand, scan-build will warn about the values not being
-+	 * used, so add a DUK_UNREF.
-+	 */
-+	nargs = 0; DUK_UNREF(nargs);
-+	nregs = 0; DUK_UNREF(nregs);
-+
-+	if (func == NULL) {
-+		duk_small_uint_t lf_flags;
-+
-+		DUK_DDD(DUK_DDDPRINT("lightfunc call handling"));
-+		DUK_ASSERT(DUK_TVAL_IS_LIGHTFUNC(tv_func));
-+		lf_flags = DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv_func);
-+		nargs = DUK_LFUNC_FLAGS_GET_NARGS(lf_flags);
-+		if (nargs == DUK_LFUNC_NARGS_VARARGS) {
-+			nargs = -1;  /* vararg */
-+		}
-+		nregs = nargs;
-+	} else if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-+		nargs = ((duk_hcompiledfunction *) func)->nargs;
-+		nregs = ((duk_hcompiledfunction *) func)->nregs;
-+		DUK_ASSERT(nregs >= nargs);
-+	} else if (DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
-+		/* Note: nargs (and nregs) may be negative for a native,
-+		 * function, which indicates that the function wants the
-+		 * input stack "as is" (i.e. handles "vararg" arguments).
-+		 */
-+		nargs = ((duk_hnativefunction *) func)->nargs;
-+		nregs = nargs;
-+	} else {
-+		/* XXX: this should be an assert */
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, DUK_STR_NOT_CALLABLE);
-+	}
-+
-+	/* [ ... func this arg1 ... argN ] */
-+
-+	/*
-+	 *  Setup a preliminary activation.
-+	 *
-+	 *  Don't touch valstack_bottom or valstack_top yet so that Duktape API
-+	 *  calls work normally.
-+	 */
-+
-+	duk_hthread_callstack_grow(thr);
-+
-+	if (thr->callstack_top > 0) {
-+		/*
-+		 *  Update idx_retval of current activation.
-+		 *
-+		 *  Although it might seem this is not necessary (bytecode executor
-+		 *  does this for Ecmascript-to-Ecmascript calls; other calls are
-+		 *  handled here), this turns out to be necessary for handling yield
-+		 *  and resume.  For them, an Ecmascript-to-native call happens, and
-+		 *  the Ecmascript call's idx_retval must be set for things to work.
-+		 */
-+
-+		(thr->callstack + thr->callstack_top - 1)->idx_retval = entry_valstack_bottom_index + idx_func;
-+	}
-+
-+	DUK_ASSERT(thr->callstack_top < thr->callstack_size);
-+	act = thr->callstack + thr->callstack_top;
-+	thr->callstack_top++;
-+	DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
-+	DUK_ASSERT(thr->valstack_top > thr->valstack_bottom);  /* at least effective 'this' */
-+	DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));
-+
-+	act->flags = 0;
-+	if (func == NULL || DUK_HOBJECT_HAS_STRICT(func)) {
-+		act->flags |= DUK_ACT_FLAG_STRICT;
-+	}
-+	if (call_flags & DUK_CALL_FLAG_CONSTRUCTOR_CALL) {
-+		act->flags |= DUK_ACT_FLAG_CONSTRUCT;
-+		/*act->flags |= DUK_ACT_FLAG_PREVENT_YIELD;*/
-+	}
-+	if (func == NULL || DUK_HOBJECT_IS_NATIVEFUNCTION(func)) {
-+		/*act->flags |= DUK_ACT_FLAG_PREVENT_YIELD;*/
-+	}
-+	if (call_flags & DUK_CALL_FLAG_DIRECT_EVAL) {
-+		act->flags |= DUK_ACT_FLAG_DIRECT_EVAL;
-+	}
-+
-+	/* As a first approximation, all calls except Ecmascript-to-Ecmascript
-+	 * calls prevent a yield.
-+	 */
-+	act->flags |= DUK_ACT_FLAG_PREVENT_YIELD;
-+
-+	act->func = func;  /* NULL for lightfunc */
-+	act->var_env = NULL;
-+	act->lex_env = NULL;
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+	act->prev_caller = NULL;
-+#endif
-+	act->pc = 0;
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	act->prev_line = 0;
-+#endif
-+	act->idx_bottom = entry_valstack_bottom_index + idx_args;
-+#if 0  /* topmost activation idx_retval is considered garbage, no need to init */
-+	act->idx_retval = 0;
-+#endif
-+	DUK_TVAL_SET_TVAL(&act->tv_func, tv_func);  /* borrowed, no refcount */
-+
-+	if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
-+		/* duk_hthread_callstack_unwind() will decrease this on unwind */
-+		thr->callstack_preventcount++;
-+	}
-+
-+	/* XXX: Is this INCREF necessary? 'func' is always a borrowed
-+	 * reference reachable through the value stack?  If changed, stack
-+	 * unwind code also needs to be fixed to match.
-+	 */
-+	DUK_HOBJECT_INCREF_ALLOWNULL(thr, func);  /* act->func */
-+
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+	if (func) {
-+		duk__update_func_caller_prop(thr, func);
-+	}
-+	act = thr->callstack + thr->callstack_top - 1;
-+#endif
-+
-+	/* [... func this arg1 ... argN] */
-+
-+	/*
-+	 *  Environment record creation and 'arguments' object creation.
-+	 *  Named function expression name binding is handled by the
-+	 *  compiler; the compiled function's parent env will contain
-+	 *  the (immutable) binding already.
-+	 *
-+	 *  This handling is now identical for C and Ecmascript functions.
-+	 *  C functions always have the 'NEWENV' flag set, so their
-+	 *  environment record initialization is delayed (which is good).
-+	 *
-+	 *  Delayed creation (on demand) is handled in duk_js_var.c.
-+	 */
-+
-+	DUK_ASSERT(func == NULL || !DUK_HOBJECT_HAS_BOUND(func));  /* bound function chain has already been resolved */
-+
-+	if (func != NULL && !DUK_HOBJECT_HAS_NEWENV(func)) {
-+		/* use existing env (e.g. for non-strict eval); cannot have
-+		 * an own 'arguments' object (but can refer to the existing one)
-+		 */
-+
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_CREATEARGS(func));
-+
-+		duk__handle_oldenv_for_call(thr, func, act);
-+
-+		DUK_ASSERT(act->lex_env != NULL);
-+		DUK_ASSERT(act->var_env != NULL);
-+		goto env_done;
-+	}
-+
-+	DUK_ASSERT(func == NULL || DUK_HOBJECT_HAS_NEWENV(func));
-+
-+	if (func == NULL || !DUK_HOBJECT_HAS_CREATEARGS(func)) {
-+		/* no need to create environment record now; leave as NULL */
-+		DUK_ASSERT(act->lex_env == NULL);
-+		DUK_ASSERT(act->var_env == NULL);
-+		goto env_done;
-+	}
-+
-+	/* third arg: absolute index (to entire valstack) of idx_bottom of new activation */
-+	env = duk_create_activation_environment_record(thr, func, act->idx_bottom);
-+	DUK_ASSERT(env != NULL);
-+
-+	/* [... func this arg1 ... argN envobj] */
-+
-+	DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func));
-+	duk__handle_createargs_for_call(thr, func, env, num_stack_args);
-+
-+	/* [... func this arg1 ... argN envobj] */
-+
-+	act->lex_env = env;
-+	act->var_env = env;
-+	DUK_HOBJECT_INCREF(thr, env);
-+	DUK_HOBJECT_INCREF(thr, env);  /* XXX: incref by count (2) directly */
-+	duk_pop(ctx);
-+
-+ env_done:
-+	/* [... func this arg1 ... argN] */
-+
-+	/*
-+	 *  Setup value stack: clamp to 'nargs', fill up to 'nregs'
-+	 *
-+	 *  Value stack may either grow or shrink, depending on the
-+	 *  number of func registers and the number of actual arguments.
-+	 *  If nregs >= 0, func wants args clamped to 'nargs'; else it
-+	 *  wants all args (= 'num_stack_args').
-+	 */
-+
-+	duk__adjust_valstack_and_top(thr,
-+	                             num_stack_args,
-+	                             idx_args,
-+	                             nregs,
-+	                             nargs,
-+	                             func);
-+
-+	/*
-+	 *  Determine call type; then setup activation and call
-+	 */
-+
-+	if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-+		goto ecmascript_call;
-+	} else {
-+		goto native_call;
-+	}
-+	DUK_UNREACHABLE();
-+
-+	/*
-+	 *  Native (C) call
-+	 */
-+
-+ native_call:
-+	/*
-+	 *  Shift to new valstack_bottom.
-+	 */
-+
-+	thr->valstack_bottom = thr->valstack_bottom + idx_args;
-+	/* keep current valstack_top */
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+	DUK_ASSERT(func == NULL || ((duk_hnativefunction *) func)->func != NULL);
-+
-+	/* [... func this | arg1 ... argN] ('this' must precede new bottom) */
-+
-+	/*
-+	 *  Actual function call and return value check.
-+	 *
-+	 *  Return values:
-+	 *    0    success, no return value (default to 'undefined')
-+	 *    1    success, one return value on top of stack
-+	 *  < 0    error, throw a "magic" error
-+	 *  other  invalid
-+	 */
-+
-+	if (func) {
-+		rc = ((duk_hnativefunction *) func)->func((duk_context *) thr);
-+	} else {
-+		duk_c_function funcptr = DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func);
-+		rc = funcptr((duk_context *) thr);
-+	}
-+
-+	if (rc < 0) {
-+		duk_error_throw_from_negative_rc(thr, rc);
-+		DUK_UNREACHABLE();
-+	} else if (rc > 1) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, "c function returned invalid rc");
-+	}
-+	DUK_ASSERT(rc == 0 || rc == 1);
-+
-+	/*
-+	 *  Unwind stack(s) and shift back to old valstack_bottom.
-+	 */
-+
-+	DUK_ASSERT(thr->catchstack_top == entry_catchstack_top);
-+	DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1);
-+
-+#if 0  /* should be no need to unwind */
-+	duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
-+#endif
-+	duk_hthread_callstack_unwind(thr, entry_callstack_top);
-+
-+	thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
-+	/* keep current valstack_top */
-+
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+	DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1);
-+
-+	/*
-+	 *  Manipulate value stack so that return value is on top
-+	 *  (pushing an 'undefined' if necessary).
-+	 */
-+
-+	/* XXX: should this happen in the callee's activation or after unwinding? */
-+	if (rc == 0) {
-+		duk_require_stack(ctx, 1);
-+		duk_push_undefined(ctx);
-+	}
-+	/* [... func this (crud) retval] */
-+
-+	DUK_DDD(DUK_DDDPRINT("native call retval -> %!T (rc=%ld)",
-+	                     (duk_tval *) duk_get_tval(ctx, -1), (long) rc));
-+
-+	duk_replace(ctx, idx_func);
-+	duk_set_top(ctx, idx_func + 1);
-+
-+	/* [... retval] */
-+
-+	/* Ensure there is internal valstack spare before we exit; this may
-+	 * throw an alloc error.  The same guaranteed size must be available
-+	 * as before the call.  This is not optimal now: we store the valstack
-+	 * allocated size during entry; this value may be higher than the
-+	 * minimal guarantee for an application.
-+	 */
-+
-+	(void) duk_valstack_resize_raw((duk_context *) thr,
-+	                               entry_valstack_end,                    /* same as during entry */
-+	                               DUK_VSRESIZE_FLAG_SHRINK |             /* flags */
-+	                               DUK_VSRESIZE_FLAG_COMPACT |
-+	                               DUK_VSRESIZE_FLAG_THROW);
-+
-+
-+	/*
-+	 *  Shrink checks and return with success.
-+	 */
-+
-+	retval = DUK_EXEC_SUCCESS;
-+	goto shrink_and_finished;
-+
-+	/*
-+	 *  Ecmascript call
-+	 */
-+
-+ ecmascript_call:
-+
-+	/*
-+	 *  Shift to new valstack_bottom.
-+	 */
-+
-+	thr->valstack_bottom = thr->valstack_bottom + idx_args;
-+	/* keep current valstack_top */
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+
-+	/* [... func this | arg1 ... argN] ('this' must precede new bottom) */
-+
-+	/*
-+	 *  Bytecode executor call.
-+	 *
-+	 *  Execute bytecode, handling any recursive function calls and
-+	 *  thread resumptions.  Returns when execution would return from
-+	 *  the entry level activation.  When the executor returns, a
-+	 *  single return value is left on the stack top.
-+	 *
-+	 *  The only possible longjmp() is an error (DUK_LJ_TYPE_THROW),
-+	 *  other types are handled internally by the executor.
-+	 *
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("entering bytecode execution"));
-+	duk_js_execute_bytecode(thr);
-+	DUK_DDD(DUK_DDDPRINT("returned from bytecode execution"));
-+
-+	/*
-+	 *  Unwind stack(s) and shift back to old valstack_bottom.
-+	 */
-+
-+	DUK_ASSERT(thr->callstack_top == entry_callstack_top + 1);
-+
-+	duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
-+	duk_hthread_callstack_unwind(thr, entry_callstack_top);
-+
-+	thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
-+	/* keep current valstack_top */
-+
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+	DUK_ASSERT(thr->valstack_top - thr->valstack_bottom >= idx_func + 1);
-+
-+	/*
-+	 *  Manipulate value stack so that return value is on top.
-+	 */
-+
-+	/* [... func this (crud) retval] */
-+
-+	duk_replace(ctx, idx_func);
-+	duk_set_top(ctx, idx_func + 1);
-+
-+	/* [... retval] */
-+
-+	/* Ensure there is internal valstack spare before we exit; this may
-+	 * throw an alloc error.  The same guaranteed size must be available
-+	 * as before the call.  This is not optimal now: we store the valstack
-+	 * allocated size during entry; this value may be higher than the
-+	 * minimal guarantee for an application.
-+	 */
-+
-+	(void) duk_valstack_resize_raw((duk_context *) thr,
-+	                               entry_valstack_end,                    /* same as during entry */
-+	                               DUK_VSRESIZE_FLAG_SHRINK |             /* flags */
-+	                               DUK_VSRESIZE_FLAG_COMPACT |
-+	                               DUK_VSRESIZE_FLAG_THROW);
-+
-+	/*
-+	 *  Shrink checks and return with success.
-+	 */
-+
-+	retval = DUK_EXEC_SUCCESS;
-+	goto shrink_and_finished;
-+
-+ shrink_and_finished:
-+#if defined(DUK_OPT_FASTINT)
-+	/* Explicit check for fastint downgrade. */
-+	{
-+		duk_tval *tv_fi;
-+		tv_fi = duk_get_tval(ctx, -1);
-+		DUK_ASSERT(tv_fi != NULL);
-+		DUK_TVAL_CHKFAST_INPLACE(tv_fi);
-+	}
-+#endif
-+
-+	/* these are "soft" shrink checks, whose failures are ignored */
-+	/* XXX: would be nice if fast path was inlined */
-+	duk_hthread_catchstack_shrink_check(thr);
-+	duk_hthread_callstack_shrink_check(thr);
-+	goto finished;
-+
-+ finished:
-+	if (need_setjmp) {
-+		/* Note: either pointer may be NULL (at entry), so don't assert;
-+		 * this is now done potentially twice, which is OK
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p (possibly already done)",
-+		                     (void *) (thr && thr->heap ? thr->heap->lj.jmpbuf_ptr : NULL),
-+		                     (void *) old_jmpbuf_ptr));
-+		thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
-+
-+		/* These are just convenience "wiping" of state */
-+		thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN;
-+		thr->heap->lj.iserror = 0;
-+
-+		/* Side effects should not be an issue here: tv_tmp is local and
-+		 * thr->heap (and thr->heap->lj) have a stable pointer.  Finalizer
-+		 * runs etc capture even out-of-memory errors so nothing should
-+		 * throw here.
-+		 */
-+		DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1);
-+		DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+		DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2);
-+		DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+		DUK_DDD(DUK_DDDPRINT("setjmp catchpoint torn down"));
-+	}
-+
-+	DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread);  /* may be NULL */
-+	thr->state = (duk_uint8_t) entry_thread_state;
-+
-+	DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) ||  /* first call */
-+	           (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) ||  /* other call */
-+	           (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr));     /* current thread */
-+
-+	thr->heap->call_recursion_depth = entry_call_recursion_depth;
-+
-+	return retval;
-+
-+ thread_state_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for call (%ld)", (long) thr->state);
-+	DUK_UNREACHABLE();
-+	return DUK_EXEC_ERROR;  /* never executed */
-+}
-+
-+/*
-+ *  Manipulate value stack so that exactly 'num_stack_rets' return
-+ *  values are at 'idx_retbase' in every case, assuming there are
-+ *  'rc' return values on top of stack.
-+ *
-+ *  This is a bit tricky, because the called C function operates in
-+ *  the same activation record and may have e.g. popped the stack
-+ *  empty (below idx_retbase).
-+ */
-+
-+DUK_LOCAL void duk__safe_call_adjust_valstack(duk_hthread *thr, duk_idx_t idx_retbase, duk_idx_t num_stack_rets, duk_idx_t num_actual_rets) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_idx_t idx_rcbase;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(idx_retbase >= 0);
-+	DUK_ASSERT(num_stack_rets >= 0);
-+	DUK_ASSERT(num_actual_rets >= 0);
-+
-+	idx_rcbase = duk_get_top(ctx) - num_actual_rets;  /* base of known return values */
-+
-+	DUK_DDD(DUK_DDDPRINT("adjust valstack after func call: "
-+	                     "num_stack_rets=%ld, num_actual_rets=%ld, stack_top=%ld, idx_retbase=%ld, idx_rcbase=%ld",
-+	                     (long) num_stack_rets, (long) num_actual_rets, (long) duk_get_top(ctx),
-+	                     (long) idx_retbase, (long) idx_rcbase));
-+
-+	DUK_ASSERT(idx_rcbase >= 0);  /* caller must check */
-+
-+	/* ensure space for final configuration (idx_retbase + num_stack_rets) and
-+	 * intermediate configurations
-+	 */
-+	duk_require_stack_top(ctx,
-+	                      (idx_rcbase > idx_retbase ? idx_rcbase : idx_retbase) +
-+	                      num_stack_rets);
-+
-+	/* chop extra retvals away / extend with undefined */
-+	duk_set_top(ctx, idx_rcbase + num_stack_rets);
-+
-+	if (idx_rcbase >= idx_retbase) {
-+		duk_idx_t count = idx_rcbase - idx_retbase;
-+		duk_idx_t i;
-+
-+		DUK_DDD(DUK_DDDPRINT("elements at/after idx_retbase have enough to cover func retvals "
-+		                     "(idx_retbase=%ld, idx_rcbase=%ld)", (long) idx_retbase, (long) idx_rcbase));
-+
-+		/* nuke values at idx_retbase to get the first retval (initially
-+		 * at idx_rcbase) to idx_retbase
-+		 */
-+
-+		DUK_ASSERT(count >= 0);
-+
-+		for (i = 0; i < count; i++) {
-+			/* XXX: inefficient; block remove primitive */
-+			duk_remove(ctx, idx_retbase);
-+		}
-+	} else {
-+		duk_idx_t count = idx_retbase - idx_rcbase;
-+		duk_idx_t i;
-+
-+		DUK_DDD(DUK_DDDPRINT("not enough elements at/after idx_retbase to cover func retvals "
-+		                     "(idx_retbase=%ld, idx_rcbase=%ld)", (long) idx_retbase, (long) idx_rcbase));
-+
-+		/* insert 'undefined' values at idx_rcbase to get the
-+		 * return values to idx_retbase
-+		 */
-+
-+		DUK_ASSERT(count > 0);
-+
-+		for (i = 0; i < count; i++) {
-+			/* XXX: inefficient; block insert primitive */
-+			duk_push_undefined(ctx);
-+			duk_insert(ctx, idx_rcbase);
-+		}
-+	}
-+}
-+
-+/*
-+ *  Make a "C protected call" within the current activation.
-+ *
-+ *  The allowed thread states for making a call are the same as for
-+ *  duk_handle_call().
-+ *
-+ *  Note that like duk_handle_call(), even if this call is protected,
-+ *  there are a few situations where the current (pre-entry) setjmp
-+ *  catcher (or a fatal error handler if no such catcher exists) is
-+ *  invoked:
-+ *
-+ *    - Blatant API argument errors (e.g. num_stack_args is invalid,
-+ *      so we can't form a reasonable return stack)
-+ *
-+ *    - Errors during error handling, e.g. failure to reallocate
-+ *      space in the value stack due to an alloc error
-+ *
-+ *  Such errors propagate outwards, ultimately to the fatal error
-+ *  handler if nothing else.
-+ */
-+
-+/* XXX: bump preventcount by one for the duration of this call? */
-+
-+DUK_INTERNAL
-+duk_int_t duk_handle_safe_call(duk_hthread *thr,
-+                               duk_safe_call_function func,
-+                               duk_idx_t num_stack_args,
-+                               duk_idx_t num_stack_rets) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_size_t entry_valstack_bottom_index;
-+	duk_size_t entry_callstack_top;
-+	duk_size_t entry_catchstack_top;
-+	duk_int_t entry_call_recursion_depth;
-+	duk_hthread *entry_curr_thread;
-+	duk_uint_fast8_t entry_thread_state;
-+	duk_jmpbuf *old_jmpbuf_ptr = NULL;
-+	duk_jmpbuf our_jmpbuf;
-+	duk_tval tv_tmp;
-+	duk_idx_t idx_retbase;
-+	duk_int_t retval;
-+	duk_ret_t rc;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/* Note: careful with indices like '-x'; if 'x' is zero, it refers to bottom */
-+	entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
-+	entry_callstack_top = thr->callstack_top;
-+	entry_catchstack_top = thr->catchstack_top;
-+	entry_call_recursion_depth = thr->heap->call_recursion_depth;
-+	entry_curr_thread = thr->heap->curr_thread;  /* Note: may be NULL if first call */
-+	entry_thread_state = thr->state;
-+	idx_retbase = duk_get_top(ctx) - num_stack_args;  /* Note: not a valid stack index if num_stack_args == 0 */
-+
-+	/* Note: cannot portably debug print a function pointer, hence 'func' not printed! */
-+	DUK_DD(DUK_DDPRINT("duk_handle_safe_call: thr=%p, num_stack_args=%ld, num_stack_rets=%ld, "
-+	                   "valstack_top=%ld, idx_retbase=%ld, rec_depth=%ld/%ld, "
-+	                   "entry_valstack_bottom_index=%ld, entry_callstack_top=%ld, entry_catchstack_top=%ld, "
-+	                   "entry_call_recursion_depth=%ld, entry_curr_thread=%p, entry_thread_state=%ld",
-+	                   (void *) thr,
-+	                   (long) num_stack_args,
-+	                   (long) num_stack_rets,
-+	                   (long) duk_get_top(ctx),
-+	                   (long) idx_retbase,
-+	                   (long) thr->heap->call_recursion_depth,
-+	                   (long) thr->heap->call_recursion_limit,
-+	                   (long) entry_valstack_bottom_index,
-+	                   (long) entry_callstack_top,
-+	                   (long) entry_catchstack_top,
-+	                   (long) entry_call_recursion_depth,
-+	                   (void *) entry_curr_thread,
-+	                   (long) entry_thread_state));
-+
-+	if (idx_retbase < 0) {
-+		/*
-+		 *  Since stack indices are not reliable, we can't do anything useful
-+		 *  here.  Invoke the existing setjmp catcher, or if it doesn't exist,
-+		 *  call the fatal error handler.
-+		 */
-+
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+	}
-+
-+	/* setjmp catchpoint setup */
-+
-+	old_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr;
-+	thr->heap->lj.jmpbuf_ptr = &our_jmpbuf;
-+
-+	if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb) == 0) {
-+		goto handle_call;
-+	}
-+
-+	/*
-+	 *  Error during call.  The error value is at heap->lj.value1.
-+	 *
-+	 *  Careful with variable accesses here; must be assigned to before
-+	 *  setjmp() or be declared volatile.  See duk_handle_call().
-+	 *
-+	 *  The following are such variables:
-+	 *    - duk_handle_safe_call() parameters
-+	 *    - entry_*
-+	 *    - idx_retbase
-+	 *
-+	 *  The very first thing we do is restore the previous setjmp catcher.
-+	 *  This means that any error in error handling will propagate outwards
-+	 *  instead of causing a setjmp() re-entry above.  The *only* actual
-+	 *  errors that should happen here are allocation errors.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("error caught during protected duk_handle_safe_call()"));
-+
-+	DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW);
-+	DUK_ASSERT(thr->callstack_top >= entry_callstack_top);
-+	DUK_ASSERT(thr->catchstack_top >= entry_catchstack_top);
-+
-+	/* Note: either pointer may be NULL (at entry), so don't assert;
-+	 * these are now restored twice which is OK.
-+	 */
-+	thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
-+
-+	duk_hthread_catchstack_unwind(thr, entry_catchstack_top);
-+	duk_hthread_callstack_unwind(thr, entry_callstack_top);
-+	thr->valstack_bottom = thr->valstack + entry_valstack_bottom_index;
-+
-+	/* [ ... | (crud) ] */
-+
-+	/* XXX: space in valstack?  see discussion in duk_handle_call. */
-+	duk_push_tval(ctx, &thr->heap->lj.value1);
-+
-+	/* [ ... | (crud) errobj ] */
-+
-+	DUK_ASSERT(duk_get_top(ctx) >= 1);  /* at least errobj must be on stack */
-+
-+	/* check that the valstack has space for the final amount and any
-+	 * intermediate space needed; this is unoptimal but should be safe
-+	 */
-+	duk_require_stack_top(ctx, idx_retbase + num_stack_rets);  /* final configuration */
-+	duk_require_stack(ctx, num_stack_rets);
-+
-+	duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, 1);  /* 1 = num actual 'return values' */
-+
-+	/* [ ... | ] or [ ... | errobj (M * undefined)] where M = num_stack_rets - 1 */
-+
-+	retval = DUK_EXEC_ERROR;
-+	goto shrink_and_finished;
-+
-+	/*
-+	 *  Handle call (inside setjmp)
-+	 */
-+
-+ handle_call:
-+
-+	DUK_DDD(DUK_DDDPRINT("safe_call setjmp catchpoint setup complete"));
-+
-+	/*
-+	 *  Thread state check and book-keeping.
-+	 */
-+
-+	if (thr == thr->heap->curr_thread) {
-+		/* same thread */
-+		if (thr->state != DUK_HTHREAD_STATE_RUNNING) {
-+			/* should actually never happen, but check anyway */
-+			goto thread_state_error;
-+		}
-+	} else {
-+		/* different thread */
-+		DUK_ASSERT(thr->heap->curr_thread == NULL ||
-+		           thr->heap->curr_thread->state == DUK_HTHREAD_STATE_RUNNING);
-+		if (thr->state != DUK_HTHREAD_STATE_INACTIVE) {
-+			goto thread_state_error;
-+		}
-+		DUK_HEAP_SWITCH_THREAD(thr->heap, thr);
-+		thr->state = DUK_HTHREAD_STATE_RUNNING;
-+
-+		/* Note: multiple threads may be simultaneously in the RUNNING
-+		 * state, but not in the same "resume chain".
-+		 */
-+	}
-+
-+	DUK_ASSERT(thr->heap->curr_thread == thr);
-+	DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
-+
-+	/*
-+	 *  Recursion limit check.
-+	 *
-+	 *  Note: there is no need for an "ignore recursion limit" flag
-+	 *  for duk_handle_safe_call now.
-+	 */
-+
-+	DUK_ASSERT(thr->heap->call_recursion_depth >= 0);
-+	DUK_ASSERT(thr->heap->call_recursion_depth <= thr->heap->call_recursion_limit);
-+	if (thr->heap->call_recursion_depth >= thr->heap->call_recursion_limit) {
-+		/* XXX: error message is a bit misleading: we reached a recursion
-+		 * limit which is also essentially the same as a C callstack limit
-+		 * (except perhaps with some relaxed threading assumptions).
-+		 */
-+		DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_C_CALLSTACK_LIMIT);
-+	}
-+	thr->heap->call_recursion_depth++;
-+
-+	/*
-+	 *  Valstack spare check
-+	 */
-+
-+	duk_require_stack(ctx, 0);  /* internal spare */
-+
-+	/*
-+	 *  Make the C call
-+	 */
-+
-+	rc = func(ctx);
-+
-+	DUK_DDD(DUK_DDDPRINT("safe_call, func rc=%ld", (long) rc));
-+
-+	/*
-+	 *  Valstack manipulation for results
-+	 */
-+
-+	/* we're running inside the caller's activation, so no change in call/catch stack or valstack bottom */
-+	DUK_ASSERT(thr->callstack_top == entry_callstack_top);
-+	DUK_ASSERT(thr->catchstack_top == entry_catchstack_top);
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT((duk_size_t) (thr->valstack_bottom - thr->valstack) == entry_valstack_bottom_index);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+
-+	if (rc < 0) {
-+		duk_error_throw_from_negative_rc(thr, rc);
-+	}
-+	DUK_ASSERT(rc >= 0);
-+
-+	if (duk_get_top(ctx) < rc) {
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, "not enough stack values for safe_call rc");
-+	}
-+
-+	duk__safe_call_adjust_valstack(thr, idx_retbase, num_stack_rets, rc);
-+
-+	/* Note: no need from callstack / catchstack shrink check */
-+	retval = DUK_EXEC_SUCCESS;
-+	goto finished;
-+
-+ shrink_and_finished:
-+	/* these are "soft" shrink checks, whose failures are ignored */
-+	/* XXX: would be nice if fast path was inlined */
-+	duk_hthread_catchstack_shrink_check(thr);
-+	duk_hthread_callstack_shrink_check(thr);
-+	goto finished;
-+
-+ finished:
-+	/* Note: either pointer may be NULL (at entry), so don't assert */
-+	thr->heap->lj.jmpbuf_ptr = old_jmpbuf_ptr;
-+
-+	/* These are just convenience "wiping" of state */
-+	thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN;
-+	thr->heap->lj.iserror = 0;
-+
-+	/* Side effects should not be an issue here: tv_tmp is local and
-+	 * thr->heap (and thr->heap->lj) have a stable pointer.  Finalizer
-+	 * runs etc capture even out-of-memory errors so nothing should
-+	 * throw here.
-+	 */
-+	DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1);
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+	DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2);
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);
-+
-+	DUK_DDD(DUK_DDDPRINT("setjmp catchpoint torn down"));
-+
-+	/* XXX: because we unwind stacks above, thr->heap->curr_thread is at
-+	 * risk of pointing to an already freed thread.  This was indeed the
-+	 * case in test-bug-multithread-valgrind.c, until duk_handle_call()
-+	 * was fixed to restore thr->heap->curr_thread before rethrowing an
-+	 * uncaught error.
-+	 */
-+	DUK_HEAP_SWITCH_THREAD(thr->heap, entry_curr_thread);  /* may be NULL */
-+	thr->state = (duk_uint8_t) entry_thread_state;
-+
-+	DUK_ASSERT((thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread == NULL) ||  /* first call */
-+	           (thr->state == DUK_HTHREAD_STATE_INACTIVE && thr->heap->curr_thread != NULL) ||  /* other call */
-+	           (thr->state == DUK_HTHREAD_STATE_RUNNING && thr->heap->curr_thread == thr));     /* current thread */
-+
-+	thr->heap->call_recursion_depth = entry_call_recursion_depth;
-+
-+	/* stack discipline consistency check */
-+	DUK_ASSERT(duk_get_top(ctx) == idx_retbase + num_stack_rets);
-+
-+	return retval;
-+
-+ thread_state_error:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid thread state for safe_call (%ld)", (long) thr->state);
-+	DUK_UNREACHABLE();
-+	return DUK_EXEC_ERROR;  /* never executed */
-+}
-+
-+/*
-+ *  Helper for handling an Ecmascript-to-Ecmascript call or an Ecmascript
-+ *  function (initial) Duktape.Thread.resume().
-+ *
-+ *  Compared to normal calls handled by duk_handle_call(), there are a
-+ *  bunch of differences:
-+ *
-+ *    - the call is never protected
-+ *    - there is no C recursion depth increase (hence an "ignore recursion
-+ *      limit" flag is not applicable)
-+ *    - instead of making the call, this helper just performs the thread
-+ *      setup and returns; the bytecode executor then restarts execution
-+ *      internally
-+ *    - ecmascript functions are never 'vararg' functions (they access
-+ *      varargs through the 'arguments' object)
-+ *
-+ *  The callstack of the target contains an earlier Ecmascript call in case
-+ *  of an Ecmascript-to-Ecmascript call (whose idx_retval is updated), or
-+ *  is empty in case of an initial Duktape.Thread.resume().
-+ *
-+ *  The first thing to do here is to figure out whether an ecma-to-ecma
-+ *  call is actually possible.  It's not always the case if the target is
-+ *  a bound function; the final function may be native.  In that case,
-+ *  return an error so caller can fall back to a normal call path.
-+ */
-+
-+DUK_INTERNAL
-+duk_bool_t duk_handle_ecma_call_setup(duk_hthread *thr,
-+                                      duk_idx_t num_stack_args,
-+                                      duk_small_uint_t call_flags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_size_t entry_valstack_bottom_index;
-+	duk_idx_t idx_func;     /* valstack index of 'func' and retval (relative to entry valstack_bottom) */
-+	duk_idx_t idx_args;     /* valstack index of start of args (arg1) (relative to entry valstack_bottom) */
-+	duk_idx_t nargs;        /* # argument registers target function wants (< 0 => never for ecma calls) */
-+	duk_idx_t nregs;        /* # total registers target function wants on entry (< 0 => never for ecma calls) */
-+	duk_hobject *func;      /* 'func' on stack (borrowed reference) */
-+	duk_tval *tv_func;      /* duk_tval ptr for 'func' on stack (borrowed reference) */
-+	duk_activation *act;
-+	duk_hobject *env;
-+	duk_bool_t use_tailcall;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(!((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 && (call_flags & DUK_CALL_FLAG_IS_TAILCALL) != 0));
-+
-+	/* XXX: assume these? */
-+	DUK_ASSERT(thr->valstack != NULL);
-+	DUK_ASSERT(thr->callstack != NULL);
-+	DUK_ASSERT(thr->catchstack != NULL);
-+
-+	/* no need to handle thread state book-keeping here */
-+	DUK_ASSERT((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 ||
-+	           (thr->state == DUK_HTHREAD_STATE_RUNNING &&
-+	            thr->heap->curr_thread == thr));
-+
-+	/* if a tailcall:
-+	 *   - an Ecmascript activation must be on top of the callstack
-+	 *   - there cannot be any active catchstack entries
-+	 */
-+#ifdef DUK_USE_ASSERTIONS
-+	if (call_flags & DUK_CALL_FLAG_IS_TAILCALL) {
-+		duk_size_t our_callstack_index;
-+		duk_size_t i;
-+
-+		DUK_ASSERT(thr->callstack_top >= 1);
-+		our_callstack_index = thr->callstack_top - 1;
-+		DUK_ASSERT_DISABLE(our_callstack_index >= 0);
-+		DUK_ASSERT(our_callstack_index < thr->callstack_size);
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + our_callstack_index) != NULL);
-+		DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + our_callstack_index)));
-+
-+		/* No entry in the catchstack which would actually catch a
-+		 * throw can refer to the callstack entry being reused.
-+		 * There *can* be catchstack entries referring to the current
-+		 * callstack entry as long as they don't catch (e.g. label sites).
-+		 */
-+
-+		for (i = 0; i < thr->catchstack_top; i++) {
-+			DUK_ASSERT(thr->catchstack[i].callstack_index < our_callstack_index ||  /* refer to callstack entries below current */
-+			           DUK_CAT_GET_TYPE(thr->catchstack + i) == DUK_CAT_TYPE_LABEL); /* or a non-catching entry */
-+		}
-+	}
-+#endif  /* DUK_USE_ASSERTIONS */
-+
-+	entry_valstack_bottom_index = (duk_size_t) (thr->valstack_bottom - thr->valstack);
-+	idx_func = duk_normalize_index(thr, -num_stack_args - 2);
-+	idx_args = idx_func + 2;
-+
-+	DUK_DD(DUK_DDPRINT("handle_ecma_call_setup: thr=%p, "
-+	                   "num_stack_args=%ld, call_flags=0x%08lx (resume=%ld, tailcall=%ld), "
-+	                   "idx_func=%ld, idx_args=%ld, entry_valstack_bottom_index=%ld",
-+	                   (void *) thr,
-+	                   (long) num_stack_args,
-+	                   (unsigned long) call_flags,
-+	                   (long) ((call_flags & DUK_CALL_FLAG_IS_RESUME) != 0 ? 1 : 0),
-+	                   (long) ((call_flags & DUK_CALL_FLAG_IS_TAILCALL) != 0 ? 1 : 0),
-+	                   (long) idx_func,
-+	                   (long) idx_args,
-+	                   (long) entry_valstack_bottom_index));
-+
-+	if (idx_func < 0 || idx_args < 0) {
-+		/* XXX: assert? compiler is responsible for this never happening */
-+		DUK_ERROR(thr, DUK_ERR_API_ERROR, DUK_STR_INVALID_CALL_ARGS);
-+	}
-+
-+	/*
-+	 *  Check the function type, handle bound function chains, and prepare
-+	 *  parameters for the rest of the call handling.  Also figure out the
-+	 *  effective 'this' binding, which replaces the current value at
-+	 *  idx_func + 1.
-+	 *
-+	 *  If the target function is a 'bound' one, follow the chain of 'bound'
-+	 *  functions until a non-bound function is found.  During this process,
-+	 *  bound arguments are 'prepended' to existing ones, and the "this"
-+	 *  binding is overridden.  See E5 Section 15.3.4.5.1.
-+	 *
-+	 *  If the final target function cannot be handled by an ecma-to-ecma
-+	 *  call, return to the caller with a return value indicating this case.
-+	 *  The bound chain is resolved and the caller can resume with a plain
-+	 *  function call.
-+	 */
-+
-+	func = duk__nonbound_func_lookup(ctx, idx_func, &num_stack_args, &tv_func, call_flags);
-+	if (func == NULL || !DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-+		DUK_DDD(DUK_DDDPRINT("final target is a lightfunc/nativefunc, cannot do ecma-to-ecma call"));
-+		return 0;
-+	}
-+	/* XXX: tv_func is not actually needed */
-+
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(func));
-+
-+	duk__coerce_effective_this_binding(thr, func, idx_func + 1);
-+	DUK_DDD(DUK_DDDPRINT("effective 'this' binding is: %!T",
-+	                     duk_get_tval(ctx, idx_func + 1)));
-+
-+	nargs = ((duk_hcompiledfunction *) func)->nargs;
-+	nregs = ((duk_hcompiledfunction *) func)->nregs;
-+	DUK_ASSERT(nregs >= nargs);
-+
-+	/* [ ... func this arg1 ... argN ] */
-+
-+	/*
-+	 *  Preliminary activation record and valstack manipulation.
-+	 *  The concrete actions depend on whether the we're dealing
-+	 *  with a tailcall (reuse an existing activation), a resume,
-+	 *  or a normal call.
-+	 *
-+	 *  The basic actions, in varying order, are:
-+	 *
-+	 *    - Check stack size for call handling
-+	 *    - Grow call stack if necessary (non-tail-calls)
-+	 *    - Update current activation (idx_retval) if necessary
-+	 *      (non-tail, non-resume calls)
-+	 *    - Move start of args (idx_args) to valstack bottom
-+	 *      (tail calls)
-+	 *
-+	 *  Don't touch valstack_bottom or valstack_top yet so that Duktape API
-+	 *  calls work normally.
-+	 */
-+
-+	/* XXX: some overlapping code; cleanup */
-+	use_tailcall = call_flags & DUK_CALL_FLAG_IS_TAILCALL;
-+#if !defined(DUK_USE_TAILCALL)
-+	DUK_ASSERT(use_tailcall == 0);  /* compiler ensures this */
-+#endif
-+	if (use_tailcall) {
-+		/* tailcall cannot be flagged to resume calls, and a
-+		 * previous frame must exist
-+		 */
-+		DUK_ASSERT(thr->callstack_top >= 1);
-+		DUK_ASSERT((call_flags & DUK_CALL_FLAG_IS_RESUME) == 0);
-+
-+		act = thr->callstack + thr->callstack_top - 1;
-+		if (act->flags & DUK_ACT_FLAG_PREVENT_YIELD) {
-+			/* See: test-bug-tailcall-preventyield-assert.c. */
-+			DUK_DDD(DUK_DDDPRINT("tailcall prevented by current activation having DUK_ACT_FLAG_PREVENTYIELD"));
-+			use_tailcall = 0;
-+		} else if (DUK_HOBJECT_HAS_NOTAIL(func)) {
-+			DUK_D(DUK_DPRINT("tailcall prevented by function having a notail flag"));
-+			use_tailcall = 0;
-+		}
-+	}
-+
-+	if (use_tailcall) {
-+		duk_tval *tv1, *tv2;
-+		duk_tval tv_tmp;
-+		duk_size_t cs_index;
-+		duk_int_t i_stk;  /* must be signed for loop structure */
-+		duk_idx_t i_arg;
-+
-+		/*
-+		 *  Tailcall handling
-+		 *
-+		 *  Although the callstack entry is reused, we need to explicitly unwind
-+		 *  the current activation (or simulate an unwind).  In particular, the
-+		 *  current activation must be closed, otherwise something like
-+		 *  test-bug-reduce-judofyr.js results.  Also catchstack needs be unwound
-+		 *  because there may be non-error-catching label entries in valid tailcalls.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("is tailcall, reusing activation at callstack top, at index %ld",
-+		                     (long) (thr->callstack_top - 1)));
-+
-+		/* 'act' already set above */
-+
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(func));
-+		DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func));
-+		DUK_ASSERT((act->flags & DUK_ACT_FLAG_PREVENT_YIELD) == 0);
-+
-+		/* Unwind catchstack entries referring to the callstack entry we're reusing */
-+		cs_index = thr->callstack_top - 1;
-+		DUK_ASSERT(thr->catchstack_top <= DUK_INT_MAX);  /* catchstack limits */
-+		for (i_stk = (duk_int_t) (thr->catchstack_top - 1); i_stk >= 0; i_stk--) {
-+			duk_catcher *cat = thr->catchstack + i_stk;
-+			if (cat->callstack_index != cs_index) {
-+				/* 'i' is the first entry we'll keep */
-+				break;
-+			}
-+		}
-+		duk_hthread_catchstack_unwind(thr, i_stk + 1);
-+
-+		/* Unwind the topmost callstack entry before reusing it */
-+		DUK_ASSERT(thr->callstack_top > 0);
-+		duk_hthread_callstack_unwind(thr, thr->callstack_top - 1);
-+
-+		/* Then reuse the unwound activation; callstack was not shrunk so there is always space */
-+		thr->callstack_top++;
-+		DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
-+		act = thr->callstack + thr->callstack_top - 1;
-+
-+		/* Start filling in the activation */
-+		act->func = func;  /* don't want an intermediate exposed state with func == NULL */
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+		act->prev_caller = NULL;
-+#endif
-+		act->pc = 0;       /* don't want an intermediate exposed state with invalid pc */
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+		act->prev_line = 0;
-+#endif
-+		DUK_TVAL_SET_OBJECT(&act->tv_func, func);  /* borrowed, no refcount */
-+#ifdef DUK_USE_REFERENCE_COUNTING
-+		DUK_HOBJECT_INCREF(thr, func);
-+		act = thr->callstack + thr->callstack_top - 1;  /* side effects (currently none though) */
-+#endif
-+
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+#ifdef DUK_USE_TAILCALL
-+#error incorrect options: tailcalls enabled with function caller property
-+#endif
-+		/* XXX: this doesn't actually work properly for tail calls, so
-+		 * tail calls are disabled when DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+		 * is in use.
-+		 */
-+		duk__update_func_caller_prop(thr, func);
-+		act = thr->callstack + thr->callstack_top - 1;
-+#endif
-+
-+		act->flags = (DUK_HOBJECT_HAS_STRICT(func) ?
-+		              DUK_ACT_FLAG_STRICT | DUK_ACT_FLAG_TAILCALLED :
-+		              DUK_ACT_FLAG_TAILCALLED);
-+
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(act) == func);      /* already updated */
-+		DUK_ASSERT(act->var_env == NULL);   /* already NULLed (by unwind) */
-+		DUK_ASSERT(act->lex_env == NULL);   /* already NULLed (by unwind) */
-+		DUK_ASSERT(act->pc == 0);           /* already zeroed */
-+		act->idx_bottom = entry_valstack_bottom_index;  /* tail call -> reuse current "frame" */
-+		DUK_ASSERT(nregs >= 0);
-+#if 0  /* topmost activation idx_retval is considered garbage, no need to init */
-+		act->idx_retval = 0;
-+#endif
-+
-+		/*
-+		 *  Manipulate valstack so that args are on the current bottom and the
-+		 *  previous caller's 'this' binding (which is the value preceding the
-+		 *  current bottom) is replaced with the new 'this' binding:
-+		 *
-+		 *       [ ... this_old | (crud) func this_new arg1 ... argN ]
-+		 *  -->  [ ... this_new | arg1 ... argN ]
-+		 *
-+		 *  For tailcalling to work properly, the valstack bottom must not grow
-+		 *  here; otherwise crud would accumulate on the valstack.
-+		 */
-+
-+		tv1 = thr->valstack_bottom - 1;
-+		tv2 = thr->valstack_bottom + idx_func + 1;
-+		DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);  /* tv1 is -below- valstack_bottom */
-+		DUK_ASSERT(tv2 >= thr->valstack_bottom && tv2 < thr->valstack_top);
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+		DUK_TVAL_SET_TVAL(tv1, tv2);
-+		DUK_TVAL_INCREF(thr, tv1);
-+		DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+		for (i_arg = 0; i_arg < idx_args; i_arg++) {
-+			/* XXX: block removal API primitive */
-+			/* Note: 'func' is popped from valstack here, but it is
-+			 * already reachable from the activation.
-+			 */
-+			duk_remove(ctx, 0);
-+		}
-+		idx_func = 0; DUK_UNREF(idx_func);  /* really 'not applicable' anymore, should not be referenced after this */
-+		idx_args = 0;
-+
-+		/* [ ... this_new | arg1 ... argN ] */
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("not a tailcall, pushing a new activation to callstack, to index %ld",
-+		                     (long) (thr->callstack_top)));
-+
-+		duk_hthread_callstack_grow(thr);
-+
-+		if (call_flags & DUK_CALL_FLAG_IS_RESUME) {
-+			DUK_DDD(DUK_DDDPRINT("is resume -> no update to current activation (may not even exist)"));
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("update to current activation idx_retval"));
-+			DUK_ASSERT(thr->callstack_top < thr->callstack_size);
-+			DUK_ASSERT(thr->callstack_top >= 1);
-+			act = thr->callstack + thr->callstack_top - 1;
-+			DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL);
-+			DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(act)));
-+			act->idx_retval = entry_valstack_bottom_index + idx_func;
-+		}
-+
-+		DUK_ASSERT(thr->callstack_top < thr->callstack_size);
-+		act = thr->callstack + thr->callstack_top;
-+		thr->callstack_top++;
-+		DUK_ASSERT(thr->callstack_top <= thr->callstack_size);
-+
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(func));
-+		DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(func));
-+
-+		act->flags = (DUK_HOBJECT_HAS_STRICT(func) ?
-+		              DUK_ACT_FLAG_STRICT :
-+		              0);
-+		act->func = func;
-+		act->var_env = NULL;
-+		act->lex_env = NULL;
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+		act->prev_caller = NULL;
-+#endif
-+		act->pc = 0;
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+		act->prev_line = 0;
-+#endif
-+		act->idx_bottom = entry_valstack_bottom_index + idx_args;
-+		DUK_ASSERT(nregs >= 0);
-+#if 0  /* topmost activation idx_retval is considered garbage, no need to init */
-+		act->idx_retval = 0;
-+#endif
-+		DUK_TVAL_SET_OBJECT(&act->tv_func, func);  /* borrowed, no refcount */
-+
-+		DUK_HOBJECT_INCREF(thr, func);  /* act->func */
-+
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+		duk__update_func_caller_prop(thr, func);
-+		act = thr->callstack + thr->callstack_top - 1;
-+#endif
-+	}
-+
-+	/* [... func this arg1 ... argN]  (not tail call)
-+	 * [this | arg1 ... argN]         (tail call)
-+	 *
-+	 * idx_args updated to match
-+	 */
-+
-+	/*
-+	 *  Environment record creation and 'arguments' object creation.
-+	 *  Named function expression name binding is handled by the
-+	 *  compiler; the compiled function's parent env will contain
-+	 *  the (immutable) binding already.
-+	 *
-+	 *  Delayed creation (on demand) is handled in duk_js_var.c.
-+	 */
-+
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));  /* bound function chain has already been resolved */
-+
-+	if (!DUK_HOBJECT_HAS_NEWENV(func)) {
-+		/* use existing env (e.g. for non-strict eval); cannot have
-+		 * an own 'arguments' object (but can refer to the existing one)
-+		 */
-+
-+		duk__handle_oldenv_for_call(thr, func, act);
-+
-+		DUK_ASSERT(act->lex_env != NULL);
-+		DUK_ASSERT(act->var_env != NULL);
-+		goto env_done;
-+	}
-+
-+	DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func));
-+
-+	if (!DUK_HOBJECT_HAS_CREATEARGS(func)) {
-+		/* no need to create environment record now; leave as NULL */
-+		DUK_ASSERT(act->lex_env == NULL);
-+		DUK_ASSERT(act->var_env == NULL);
-+		goto env_done;
-+	}
-+
-+	/* third arg: absolute index (to entire valstack) of idx_bottom of new activation */
-+	env = duk_create_activation_environment_record(thr, func, act->idx_bottom);
-+	DUK_ASSERT(env != NULL);
-+
-+	/* [... arg1 ... argN envobj] */
-+
-+	/* original input stack before nargs/nregs handling must be
-+	 * intact for 'arguments' object
-+	 */
-+	DUK_ASSERT(DUK_HOBJECT_HAS_CREATEARGS(func));
-+	duk__handle_createargs_for_call(thr, func, env, num_stack_args);
-+
-+	/* [... arg1 ... argN envobj] */
-+
-+	act->lex_env = env;
-+	act->var_env = env;
-+	DUK_HOBJECT_INCREF(thr, act->lex_env);
-+	DUK_HOBJECT_INCREF(thr, act->var_env);
-+	duk_pop(ctx);
-+
-+ env_done:
-+	/* [... arg1 ... argN] */
-+
-+	/*
-+	 *  Setup value stack: clamp to 'nargs', fill up to 'nregs'
-+	 */
-+
-+	duk__adjust_valstack_and_top(thr,
-+	                             num_stack_args,
-+	                             idx_args,
-+	                             nregs,
-+	                             nargs,
-+	                             func);
-+
-+	/*
-+	 *  Shift to new valstack_bottom.
-+	 */
-+
-+	thr->valstack_bottom = thr->valstack_bottom + idx_args;
-+	/* keep current valstack_top */
-+	DUK_ASSERT(thr->valstack_bottom >= thr->valstack);
-+	DUK_ASSERT(thr->valstack_top >= thr->valstack_bottom);
-+	DUK_ASSERT(thr->valstack_end >= thr->valstack_top);
-+
-+	/*
-+	 *  Return to bytecode executor, which will resume execution from
-+	 *  the topmost activation.
-+	 */
-+
-+	return 1;
-+}
-+#line 1 "duk_js_compiler.c"
-+/*
-+ *  Ecmascript compiler.
-+ *
-+ *  Parses an input string and generates a function template result.
-+ *  Compilation may happen in multiple contexts (global code, eval
-+ *  code, function code).
-+ *
-+ *  The parser uses a traditional top-down recursive parsing for the
-+ *  statement level, and an operator precedence based top-down approach
-+ *  for the expression level.  The attempt is to minimize the C stack
-+ *  depth.  Bytecode is generated directly without an intermediate
-+ *  representation (tree), at the cost of needing two passes over each
-+ *  function.
-+ *
-+ *  The top-down recursive parser functions are named "duk__parse_XXX".
-+ *
-+ *  Recursion limits are in key functions to prevent arbitrary C recursion:
-+ *  function body parsing, statement parsing, and expression parsing.
-+ *
-+ *  See doc/compiler.txt for discussion on the design.
-+ *
-+ *  A few typing notes:
-+ *
-+ *    - duk_regconst_t: unsigned, no marker value for "none"
-+ *    - duk_reg_t: signed, < 0 = none
-+ *    - PC values: duk_int_t, negative values used as markers
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* if highest bit of a register number is set, it refers to a constant instead */
-+#define DUK__CONST_MARKER                 DUK_JS_CONST_MARKER
-+
-+/* for array and object literals */
-+#define DUK__MAX_ARRAY_INIT_VALUES        20
-+#define DUK__MAX_OBJECT_INIT_PAIRS        10
-+
-+/* XXX: hack, remove when const lookup is not O(n) */
-+#define DUK__GETCONST_MAX_CONSTS_CHECK    256
-+
-+/* These limits are based on bytecode limits.  Max temps is limited
-+ * by duk_hcompiledfunction nargs/nregs fields being 16 bits.
-+ */
-+#define DUK__MAX_CONSTS                   DUK_BC_BC_MAX
-+#define DUK__MAX_FUNCS                    DUK_BC_BC_MAX
-+#define DUK__MAX_TEMPS                    0xffffL
-+
-+#define DUK__RECURSION_INCREASE(comp_ctx,thr)  do { \
-+		DUK_DDD(DUK_DDDPRINT("RECURSION INCREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \
-+		duk__recursion_increase((comp_ctx)); \
-+	} while (0)
-+
-+#define DUK__RECURSION_DECREASE(comp_ctx,thr)  do { \
-+		DUK_DDD(DUK_DDDPRINT("RECURSION DECREASE: %s:%ld", (const char *) DUK_FILE_MACRO, (long) DUK_LINE_MACRO)); \
-+		duk__recursion_decrease((comp_ctx)); \
-+	} while (0)
-+
-+/* Value stack slot limits: these are quite approximate right now, and
-+ * because they overlap in control flow, some could be eliminated.
-+ */
-+#define DUK__COMPILE_ENTRY_SLOTS          8
-+#define DUK__FUNCTION_INIT_REQUIRE_SLOTS  16
-+#define DUK__FUNCTION_BODY_REQUIRE_SLOTS  16
-+#define DUK__PARSE_STATEMENTS_SLOTS       16
-+#define DUK__PARSE_EXPR_SLOTS             16
-+
-+/* Temporary structure used to pass a stack allocated region through
-+ * duk_safe_call().
-+ */
-+typedef struct {
-+	duk_small_uint_t flags;
-+	duk_compiler_ctx comp_ctx_alloc;
-+	duk_lexer_point lex_pt_alloc;
-+} duk__compiler_stkstate;
-+
-+/*
-+ *  Prototypes
-+ */
-+
-+/* lexing */
-+DUK_LOCAL_DECL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t expect);
-+DUK_LOCAL_DECL void duk__advance_expect(duk_compiler_ctx *comp_ctx, duk_small_int_t expect);
-+DUK_LOCAL_DECL void duk__advance(duk_compiler_ctx *ctx);
-+
-+/* function helpers */
-+DUK_LOCAL_DECL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL void duk__reset_func_for_pass2(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL void duk__init_varmap_and_prologue_for_pass2(duk_compiler_ctx *comp_ctx, duk_reg_t *out_stmt_value_reg);
-+DUK_LOCAL_DECL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind);
-+DUK_LOCAL_DECL duk_int_t duk__cleanup_varmap(duk_compiler_ctx *comp_ctx);
-+
-+/* code emission */
-+DUK_LOCAL_DECL duk_int_t duk__get_current_pc(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL duk_compiler_instr *duk__get_instr_ptr(duk_compiler_ctx *comp_ctx, duk_int_t pc);
-+DUK_LOCAL_DECL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins);
-+#if 0  /* unused */
-+DUK_LOCAL_DECL void duk__emit_op_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t op);
-+#endif
-+DUK_LOCAL_DECL void duk__emit_a_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b, duk_regconst_t c);
-+DUK_LOCAL_DECL void duk__emit_a_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b);
-+#if 0  /* unused */
-+DUK_LOCAL_DECL void duk__emit_a(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a);
-+#endif
-+DUK_LOCAL_DECL void duk__emit_a_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t bc);
-+DUK_LOCAL_DECL void duk__emit_abc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc);
-+DUK_LOCAL_DECL void duk__emit_extraop_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b, duk_regconst_t c);
-+DUK_LOCAL_DECL void duk__emit_extraop_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b);
-+DUK_LOCAL_DECL void duk__emit_extraop_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop, duk_regconst_t bc);
-+DUK_LOCAL_DECL void duk__emit_extraop_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags);
-+DUK_LOCAL_DECL void duk__emit_load_int32(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val);
-+DUK_LOCAL_DECL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val);
-+DUK_LOCAL_DECL void duk__emit_jump(duk_compiler_ctx *comp_ctx, duk_int_t target_pc);
-+DUK_LOCAL_DECL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc);
-+DUK_LOCAL_DECL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc);
-+DUK_LOCAL_DECL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc);
-+DUK_LOCAL_DECL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags);
-+DUK_LOCAL_DECL void duk__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst);
-+DUK_LOCAL_DECL void duk__emit_if_true_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst);
-+DUK_LOCAL_DECL void duk__emit_invalid(duk_compiler_ctx *comp_ctx);
-+
-+/* ivalue/ispec helpers */
-+DUK_LOCAL_DECL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst);
-+DUK_LOCAL_DECL void duk__copy_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *src, duk_ivalue *dst);
-+DUK_LOCAL_DECL duk_bool_t duk__is_whole_get_int32(duk_double_t x, duk_int32_t *ival);
-+DUK_LOCAL_DECL duk_reg_t duk__alloctemps(duk_compiler_ctx *comp_ctx, duk_small_int_t num);
-+DUK_LOCAL_DECL duk_reg_t duk__alloctemp(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next);
-+DUK_LOCAL_DECL duk_regconst_t duk__getconst(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL
-+duk_regconst_t duk__ispec_toregconst_raw(duk_compiler_ctx *comp_ctx,
-+                                         duk_ispec *x,
-+                                         duk_reg_t forced_reg,
-+                                         duk_small_uint_t flags);
-+DUK_LOCAL_DECL void duk__ispec_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ispec *x, duk_reg_t forced_reg);
-+DUK_LOCAL_DECL void duk__ivalue_toplain_raw(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_reg_t forced_reg);
-+DUK_LOCAL_DECL void duk__ivalue_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-+DUK_LOCAL_DECL void duk__ivalue_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-+DUK_LOCAL_DECL
-+duk_regconst_t duk__ivalue_toregconst_raw(duk_compiler_ctx *comp_ctx,
-+                                          duk_ivalue *x,
-+                                          duk_reg_t forced_reg,
-+                                          duk_small_uint_t flags);
-+DUK_LOCAL_DECL duk_reg_t duk__ivalue_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-+#if 0  /* unused */
-+DUK_LOCAL_DECL duk_reg_t duk__ivalue_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-+#endif
-+DUK_LOCAL_DECL void duk__ivalue_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_int_t forced_reg);
-+DUK_LOCAL_DECL duk_regconst_t duk__ivalue_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x);
-+
-+/* identifier handling */
-+DUK_LOCAL_DECL duk_reg_t duk__lookup_active_register_binding(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL duk_bool_t duk__lookup_lhs(duk_compiler_ctx *ctx, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname);
-+
-+/* label handling */
-+DUK_LOCAL_DECL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_int_t pc_label, duk_int_t label_id);
-+DUK_LOCAL_DECL void duk__update_label_flags(duk_compiler_ctx *comp_ctx, duk_int_t label_id, duk_small_uint_t flags);
-+DUK_LOCAL_DECL void duk__lookup_active_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_bool_t is_break, duk_int_t *out_label_id, duk_int_t *out_label_catch_depth, duk_int_t *out_label_pc, duk_bool_t *out_is_closest);
-+DUK_LOCAL_DECL void duk__reset_labels_to_length(duk_compiler_ctx *comp_ctx, duk_int_t len);
-+
-+/* top-down expression parser */
-+DUK_LOCAL_DECL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_ivalue *res);
-+DUK_LOCAL_DECL duk_small_uint_t duk__expr_lbp(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL duk_bool_t duk__expr_is_empty(duk_compiler_ctx *comp_ctx);
-+
-+/* exprtop is the top level variant which resets nud/led counts */
-+DUK_LOCAL_DECL void duk__expr(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+DUK_LOCAL_DECL void duk__exprtop(duk_compiler_ctx *ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+
-+/* convenience helpers */
-+DUK_LOCAL_DECL duk_reg_t duk__expr_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+#if 0  /* unused */
-+DUK_LOCAL_DECL duk_reg_t duk__expr_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+#endif
-+DUK_LOCAL_DECL void duk__expr_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg);
-+DUK_LOCAL_DECL duk_regconst_t duk__expr_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+DUK_LOCAL_DECL void duk__expr_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+DUK_LOCAL_DECL void duk__expr_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+DUK_LOCAL_DECL duk_reg_t duk__exprtop_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+#if 0  /* unused */
-+DUK_LOCAL_DECL duk_reg_t duk__exprtop_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+DUK_LOCAL_DECL void duk__exprtop_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg);
-+#endif
-+DUK_LOCAL_DECL duk_regconst_t duk__exprtop_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+#if 0  /* unused */
-+DUK_LOCAL_DECL void duk__exprtop_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags);
-+#endif
-+
-+/* expression parsing helpers */
-+DUK_LOCAL_DECL duk_int_t duk__parse_arguments(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__nud_array_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__nud_object_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL duk_bool_t duk__nud_object_literal_key_check(duk_compiler_ctx *comp_ctx, duk_small_uint_t new_key_flags);
-+
-+/* statement parsing */
-+DUK_LOCAL_DECL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname);
-+DUK_LOCAL_DECL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site);
-+DUK_LOCAL_DECL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site);
-+DUK_LOCAL_DECL void duk__parse_if_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__parse_do_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site);
-+DUK_LOCAL_DECL void duk__parse_while_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site);
-+DUK_LOCAL_DECL void duk__parse_break_or_continue_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__parse_throw_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res);
-+DUK_LOCAL_DECL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_bool_t allow_source_elem);
-+DUK_LOCAL_DECL duk_int_t duk__stmt_label_site(duk_compiler_ctx *comp_ctx, duk_int_t label_id);
-+DUK_LOCAL_DECL void duk__parse_stmts(duk_compiler_ctx *comp_ctx, duk_bool_t allow_source_elem, duk_bool_t expect_eof);
-+
-+DUK_LOCAL_DECL void duk__parse_func_body(duk_compiler_ctx *comp_ctx, duk_bool_t expect_eof, duk_bool_t implicit_return_value, duk_small_int_t expect_token);
-+DUK_LOCAL_DECL void duk__parse_func_formals(duk_compiler_ctx *comp_ctx);
-+DUK_LOCAL_DECL void duk__parse_func_like_raw(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget);
-+DUK_LOCAL_DECL duk_int_t duk__parse_func_like_fnum(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget);
-+
-+/*
-+ *  Parser control values for tokens.  The token table is ordered by the
-+ *  DUK_TOK_XXX defines.
-+ *
-+ *  The binding powers are for lbp() use (i.e. for use in led() context).
-+ *  Binding powers are positive for typing convenience, and bits at the
-+ *  top should be reserved for flags.  Binding power step must be higher
-+ *  than 1 so that binding power "lbp - 1" can be used for right associative
-+ *  operators.  Currently a step of 2 is used (which frees one more bit for
-+ *  flags).
-+ */
-+
-+/* XXX: actually single step levels would work just fine, clean up */
-+
-+/* binding power "levels" (see doc/compiler.txt) */
-+#define DUK__BP_INVALID                0             /* always terminates led() */
-+#define DUK__BP_EOF                    2
-+#define DUK__BP_CLOSING                4             /* token closes expression, e.g. ')', ']' */
-+#define DUK__BP_FOR_EXPR               DUK__BP_CLOSING    /* bp to use when parsing a top level Expression */
-+#define DUK__BP_COMMA                  6
-+#define DUK__BP_ASSIGNMENT             8
-+#define DUK__BP_CONDITIONAL            10
-+#define DUK__BP_LOR                    12
-+#define DUK__BP_LAND                   14
-+#define DUK__BP_BOR                    16
-+#define DUK__BP_BXOR                   18
-+#define DUK__BP_BAND                   20
-+#define DUK__BP_EQUALITY               22
-+#define DUK__BP_RELATIONAL             24
-+#define DUK__BP_SHIFT                  26
-+#define DUK__BP_ADDITIVE               28
-+#define DUK__BP_MULTIPLICATIVE         30
-+#define DUK__BP_POSTFIX                32
-+#define DUK__BP_CALL                   34
-+#define DUK__BP_MEMBER                 36
-+
-+#define DUK__TOKEN_LBP_BP_MASK         0x1f
-+#define DUK__TOKEN_LBP_FLAG_NO_REGEXP  (1 << 5)   /* regexp literal must not follow this token */
-+#define DUK__TOKEN_LBP_FLAG_TERMINATES (1 << 6)   /* terminates expression; e.g. post-increment/-decrement */
-+#define DUK__TOKEN_LBP_FLAG_UNUSED     (1 << 7)   /* spare */
-+
-+#define DUK__TOKEN_LBP_GET_BP(x)       ((duk_small_uint_t) (((x) & DUK__TOKEN_LBP_BP_MASK) * 2))
-+
-+#define DUK__MK_LBP(bp)                ((bp) >> 1)    /* bp is assumed to be even */
-+#define DUK__MK_LBP_FLAGS(bp,flags)    (((bp) >> 1) | (flags))
-+
-+DUK_LOCAL const duk_uint8_t duk__token_lbp[] = {
-+	DUK__MK_LBP(DUK__BP_EOF),                                 /* DUK_TOK_EOF */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LINETERM */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_COMMENT */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_IDENTIFIER */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_BREAK */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CASE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CATCH */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CONTINUE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DEBUGGER */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DEFAULT */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DELETE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_DO */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_ELSE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FINALLY */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FOR */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_FUNCTION */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IF */
-+	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_IN */
-+	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_INSTANCEOF */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_NEW */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_RETURN */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SWITCH */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_THIS */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_THROW */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_TRY */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_TYPEOF */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_VAR */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_VOID */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_WHILE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_WITH */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CLASS */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_CONST */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_ENUM */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_EXPORT */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_EXTENDS */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IMPORT */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SUPER */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_NULL */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_TRUE */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_FALSE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_GET */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SET */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_IMPLEMENTS */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_INTERFACE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LET */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PACKAGE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PRIVATE */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PROTECTED */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_PUBLIC */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_STATIC */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_YIELD */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LCURLY */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RCURLY */
-+	DUK__MK_LBP(DUK__BP_MEMBER),                              /* DUK_TOK_LBRACKET */
-+	DUK__MK_LBP_FLAGS(DUK__BP_CLOSING, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RBRACKET */
-+	DUK__MK_LBP(DUK__BP_CALL),                                /* DUK_TOK_LPAREN */
-+	DUK__MK_LBP_FLAGS(DUK__BP_CLOSING, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_RPAREN */
-+	DUK__MK_LBP(DUK__BP_MEMBER),                              /* DUK_TOK_PERIOD */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_SEMICOLON */
-+	DUK__MK_LBP(DUK__BP_COMMA),                               /* DUK_TOK_COMMA */
-+	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_LT */
-+	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_GT */
-+	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_LE */
-+	DUK__MK_LBP(DUK__BP_RELATIONAL),                          /* DUK_TOK_GE */
-+	DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_EQ */
-+	DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_NEQ */
-+	DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_SEQ */
-+	DUK__MK_LBP(DUK__BP_EQUALITY),                            /* DUK_TOK_SNEQ */
-+	DUK__MK_LBP(DUK__BP_ADDITIVE),                            /* DUK_TOK_ADD */
-+	DUK__MK_LBP(DUK__BP_ADDITIVE),                            /* DUK_TOK_SUB */
-+	DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_MUL */
-+	DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_DIV */
-+	DUK__MK_LBP(DUK__BP_MULTIPLICATIVE),                      /* DUK_TOK_MOD */
-+	DUK__MK_LBP(DUK__BP_POSTFIX),                             /* DUK_TOK_INCREMENT */
-+	DUK__MK_LBP(DUK__BP_POSTFIX),                             /* DUK_TOK_DECREMENT */
-+	DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_ALSHIFT */
-+	DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_ARSHIFT */
-+	DUK__MK_LBP(DUK__BP_SHIFT),                               /* DUK_TOK_RSHIFT */
-+	DUK__MK_LBP(DUK__BP_BAND),                                /* DUK_TOK_BAND */
-+	DUK__MK_LBP(DUK__BP_BOR),                                 /* DUK_TOK_BOR */
-+	DUK__MK_LBP(DUK__BP_BXOR),                                /* DUK_TOK_BXOR */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_LNOT */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_BNOT */
-+	DUK__MK_LBP(DUK__BP_LAND),                                /* DUK_TOK_LAND */
-+	DUK__MK_LBP(DUK__BP_LOR),                                 /* DUK_TOK_LOR */
-+	DUK__MK_LBP(DUK__BP_CONDITIONAL),                         /* DUK_TOK_QUESTION */
-+	DUK__MK_LBP(DUK__BP_INVALID),                             /* DUK_TOK_COLON */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_EQUALSIGN */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_ADD_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_SUB_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_MUL_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_DIV_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_MOD_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_ALSHIFT_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_ARSHIFT_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_RSHIFT_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_BAND_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_BOR_EQ */
-+	DUK__MK_LBP(DUK__BP_ASSIGNMENT),                          /* DUK_TOK_BXOR_EQ */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_NUMBER */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_STRING */
-+	DUK__MK_LBP_FLAGS(DUK__BP_INVALID, DUK__TOKEN_LBP_FLAG_NO_REGEXP),  /* DUK_TOK_REGEXP */
-+};
-+
-+/*
-+ *  Misc helpers
-+ */
-+
-+DUK_LOCAL void duk__recursion_increase(duk_compiler_ctx *comp_ctx) {
-+	DUK_ASSERT(comp_ctx != NULL);
-+	DUK_ASSERT(comp_ctx->recursion_depth >= 0);
-+	if (comp_ctx->recursion_depth >= comp_ctx->recursion_limit) {
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_COMPILER_RECURSION_LIMIT);
-+	}
-+	comp_ctx->recursion_depth++;
-+}
-+
-+DUK_LOCAL void duk__recursion_decrease(duk_compiler_ctx *comp_ctx) {
-+	DUK_ASSERT(comp_ctx != NULL);
-+	DUK_ASSERT(comp_ctx->recursion_depth > 0);
-+	comp_ctx->recursion_depth--;
-+}
-+
-+DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments(duk_compiler_ctx *comp_ctx, duk_hstring *h) {
-+	DUK_UNREF(comp_ctx);
-+	DUK_ASSERT(h != NULL);
-+	return DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(h);
-+}
-+
-+DUK_LOCAL duk_bool_t duk__hstring_is_eval_or_arguments_in_strict_mode(duk_compiler_ctx *comp_ctx, duk_hstring *h) {
-+	DUK_ASSERT(h != NULL);
-+	return (comp_ctx->curr_func.is_strict &&
-+	        DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(h));
-+}
-+
-+/*
-+ *  Parser duk__advance() token eating functions
-+ */
-+
-+/* XXX: valstack handling is awkward.  Add a valstack helper which
-+ * avoids dup():ing; valstack_copy(src, dst)?
-+ */
-+
-+DUK_LOCAL void duk__advance_helper(duk_compiler_ctx *comp_ctx, duk_small_int_t expect) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_bool_t regexp;
-+
-+	DUK_ASSERT(comp_ctx->curr_token.t >= 0 && comp_ctx->curr_token.t <= DUK_TOK_MAXVAL);  /* MAXVAL is inclusive */
-+
-+	/*
-+	 *  Use current token to decide whether a RegExp can follow.
-+	 *
-+	 *  We can use either 't' or 't_nores'; the latter would not
-+	 *  recognize keywords.  Some keywords can be followed by a
-+	 *  RegExp (e.g. "return"), so using 't' is better.  This is
-+	 *  not trivial, see doc/compiler.txt.
-+	 */
-+
-+	regexp = 1;
-+	if (duk__token_lbp[comp_ctx->curr_token.t] & DUK__TOKEN_LBP_FLAG_NO_REGEXP) {
-+		regexp = 0;
-+	}
-+	if (comp_ctx->curr_func.reject_regexp_in_adv) {
-+		comp_ctx->curr_func.reject_regexp_in_adv = 0;
-+		regexp = 0;
-+	}
-+
-+	if (expect >= 0 && comp_ctx->curr_token.t != expect) {
-+		DUK_D(DUK_DPRINT("parse error: expect=%ld, got=%ld",
-+		                 (long) expect, (long) comp_ctx->curr_token.t));
-+		DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_PARSE_ERROR);
-+	}
-+
-+	/* make current token the previous; need to fiddle with valstack "backing store" */
-+	DUK_MEMCPY(&comp_ctx->prev_token, &comp_ctx->curr_token, sizeof(duk_token));
-+	duk_copy(ctx, comp_ctx->tok11_idx, comp_ctx->tok21_idx);
-+	duk_copy(ctx, comp_ctx->tok12_idx, comp_ctx->tok22_idx);
-+
-+	/* parse new token */
-+	duk_lexer_parse_js_input_element(&comp_ctx->lex,
-+	                                 &comp_ctx->curr_token,
-+	                                 comp_ctx->curr_func.is_strict,
-+	                                 regexp);
-+
-+	DUK_DDD(DUK_DDDPRINT("advance: curr: tok=%ld/%ld,%ld,term=%ld,%!T,%!T "
-+	                     "prev: tok=%ld/%ld,%ld,term=%ld,%!T,%!T",
-+	                     (long) comp_ctx->curr_token.t,
-+	                     (long) comp_ctx->curr_token.t_nores,
-+	                     (long) comp_ctx->curr_token.start_line,
-+	                     (long) comp_ctx->curr_token.lineterm,
-+	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->tok11_idx),
-+	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->tok12_idx),
-+	                     (long) comp_ctx->prev_token.t,
-+	                     (long) comp_ctx->prev_token.t_nores,
-+	                     (long) comp_ctx->prev_token.start_line,
-+	                     (long) comp_ctx->prev_token.lineterm,
-+	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->tok21_idx),
-+	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->tok22_idx)));
-+}
-+
-+/* advance, expecting current token to be a specific token; parse next token in regexp context */
-+DUK_LOCAL void duk__advance_expect(duk_compiler_ctx *comp_ctx, duk_small_int_t expect) {
-+	duk__advance_helper(comp_ctx, expect);
-+}
-+
-+/* advance, whatever the current token is; parse next token in regexp context */
-+DUK_LOCAL void duk__advance(duk_compiler_ctx *comp_ctx) {
-+	duk__advance_helper(comp_ctx, -1);
-+}
-+
-+/*
-+ *  Helpers for duk_compiler_func.
-+ */
-+
-+/* init function state: inits valstack allocations */
-+DUK_LOCAL void duk__init_func_valstack_slots(duk_compiler_ctx *comp_ctx) {
-+	duk_compiler_func *func = &comp_ctx->curr_func;
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_idx_t entry_top;
-+
-+	entry_top = duk_get_top(ctx);
-+
-+	DUK_MEMZERO(func, sizeof(*func));  /* intentional overlap with earlier memzero */
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	func->h_name = NULL;
-+	func->h_code = NULL;
-+	func->h_consts = NULL;
-+	func->h_funcs = NULL;
-+	func->h_decls = NULL;
-+	func->h_labelnames = NULL;
-+	func->h_labelinfos = NULL;
-+	func->h_argnames = NULL;
-+	func->h_varmap = NULL;
-+#endif
-+
-+	duk_require_stack(ctx, DUK__FUNCTION_INIT_REQUIRE_SLOTS);
-+
-+	/* XXX: getter for dynamic buffer */
-+
-+	duk_push_dynamic_buffer(ctx, 0);
-+	func->code_idx = entry_top + 0;
-+	func->h_code = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 0);
-+	DUK_ASSERT(func->h_code != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_code));
-+
-+	duk_push_array(ctx);
-+	func->consts_idx = entry_top + 1;
-+	func->h_consts = duk_get_hobject(ctx, entry_top + 1);
-+	DUK_ASSERT(func->h_consts != NULL);
-+
-+	duk_push_array(ctx);
-+	func->funcs_idx = entry_top + 2;
-+	func->h_funcs = duk_get_hobject(ctx, entry_top + 2);
-+	DUK_ASSERT(func->h_funcs != NULL);
-+	DUK_ASSERT(func->fnum_next == 0);
-+
-+	duk_push_array(ctx);
-+	func->decls_idx = entry_top + 3;
-+	func->h_decls = duk_get_hobject(ctx, entry_top + 3);
-+	DUK_ASSERT(func->h_decls != NULL);
-+
-+	duk_push_array(ctx);
-+	func->labelnames_idx = entry_top + 4;
-+	func->h_labelnames = duk_get_hobject(ctx, entry_top + 4);
-+	DUK_ASSERT(func->h_labelnames != NULL);
-+
-+	duk_push_dynamic_buffer(ctx, 0);
-+	func->labelinfos_idx = entry_top + 5;
-+	func->h_labelinfos = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 5);
-+	DUK_ASSERT(func->h_labelinfos != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_labelinfos));
-+
-+	duk_push_array(ctx);
-+	func->argnames_idx = entry_top + 6;
-+	func->h_argnames = duk_get_hobject(ctx, entry_top + 6);
-+	DUK_ASSERT(func->h_argnames != NULL);
-+
-+	duk_push_object_internal(ctx);
-+	func->varmap_idx = entry_top + 7;
-+	func->h_varmap = duk_get_hobject(ctx, entry_top + 7);
-+	DUK_ASSERT(func->h_varmap != NULL);
-+}
-+
-+/* reset function state (prepare for pass 2) */
-+DUK_LOCAL void duk__reset_func_for_pass2(duk_compiler_ctx *comp_ctx) {
-+	duk_compiler_func *func = &comp_ctx->curr_func;
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+
-+	/* XXX: reset buffers while keeping existing spare */
-+
-+	duk_hbuffer_reset(thr, func->h_code);
-+	duk_hobject_set_length_zero(thr, func->h_consts);
-+	/* keep func->h_funcs; inner functions are not reparsed to avoid O(depth^2) parsing */
-+	func->fnum_next = 0;
-+	/* duk_hobject_set_length_zero(thr, func->h_funcs); */
-+	duk_hobject_set_length_zero(thr, func->h_labelnames);
-+	duk_hbuffer_reset(thr, func->h_labelinfos);
-+	/* keep func->h_argnames; it is fixed for all passes */
-+
-+	/* truncated in case pass 3 needed */
-+	duk_push_object_internal(ctx);
-+	duk_replace(ctx, func->varmap_idx);
-+	func->h_varmap = duk_get_hobject(ctx, func->varmap_idx);
-+	DUK_ASSERT(func->h_varmap != NULL);
-+}
-+
-+/* cleanup varmap from any null entries, compact it, etc; returns number
-+ * of final entries after cleanup.
-+ */
-+DUK_LOCAL duk_int_t duk__cleanup_varmap(duk_compiler_ctx *comp_ctx) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *h_varmap;
-+	duk_hstring *h_key;
-+	duk_tval *tv;
-+	duk_uint32_t i, e_next;
-+	duk_int_t ret;
-+
-+	/* [ ... varmap ] */
-+
-+	h_varmap = duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(h_varmap != NULL);
-+
-+	ret = 0;
-+	e_next = DUK_HOBJECT_GET_ENEXT(h_varmap);
-+	for (i = 0; i < e_next; i++) {
-+		h_key = DUK_HOBJECT_E_GET_KEY(thr->heap, h_varmap, i);
-+		if (!h_key) {
-+			continue;
-+		}
-+
-+		DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h_varmap, i));
-+
-+		/* The entries can either be register numbers or 'null' values.
-+		 * Thus, no need to DECREF them and get side effects.  DECREF'ing
-+		 * the keys (strings) can cause memory to be freed but no side
-+		 * effects as strings don't have finalizers.  This is why we can
-+		 * rely on the object properties not changing from underneath us.
-+		 */
-+
-+		tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h_varmap, i);
-+		if (!DUK_TVAL_IS_NUMBER(tv)) {
-+			DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv));
-+			DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+			DUK_HOBJECT_E_SET_KEY(thr->heap, h_varmap, i, NULL);
-+			DUK_HSTRING_DECREF(thr, h_key);
-+		} else {
-+			ret++;
-+		}
-+	}
-+
-+	duk_compact(ctx, -1);
-+
-+	return ret;
-+}
-+
-+/* convert duk_compiler_func into a function template, leaving the result
-+ * on top of stack.
-+ */
-+/* XXX: awkward and bloated asm -- use faster internal accesses */
-+DUK_LOCAL void duk__convert_to_func_template(duk_compiler_ctx *comp_ctx, duk_bool_t force_no_namebind) {
-+	duk_compiler_func *func = &comp_ctx->curr_func;
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hcompiledfunction *h_res;
-+	duk_hbuffer_fixed *h_data;
-+	duk_size_t consts_count;
-+	duk_size_t funcs_count;
-+	duk_size_t code_count;
-+	duk_size_t code_size;
-+	duk_size_t data_size;
-+	duk_size_t i;
-+	duk_tval *p_const;
-+	duk_hobject **p_func;
-+	duk_instr_t *p_instr;
-+	duk_compiler_instr *q_instr;
-+	duk_tval *tv;
-+
-+	DUK_DDD(DUK_DDDPRINT("converting duk_compiler_func to function/template"));
-+	DUK_DD(DUK_DDPRINT("code=%!xO consts=%!O funcs=%!O",
-+	                   (duk_heaphdr *) func->h_code,
-+	                   (duk_heaphdr *) func->h_consts,
-+	                   (duk_heaphdr *) func->h_funcs));
-+
-+	/*
-+	 *  Push result object and init its flags
-+	 */
-+
-+	/* Valstack should suffice here, required on function valstack init */
-+
-+	(void) duk_push_compiledfunction(ctx);
-+	h_res = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);  /* XXX: specific getter */
-+	DUK_ASSERT(h_res != NULL);
-+
-+	if (func->is_function) {
-+		DUK_DDD(DUK_DDDPRINT("function -> set NEWENV"));
-+		DUK_HOBJECT_SET_NEWENV((duk_hobject *) h_res);
-+
-+		if (!func->is_arguments_shadowed) {
-+			/* arguments object would be accessible; note that shadowing
-+			 * bindings are arguments or function declarations, neither
-+			 * of which are deletable, so this is safe.
-+			 */
-+
-+			if (func->id_access_arguments || func->may_direct_eval) {
-+				DUK_DDD(DUK_DDDPRINT("function may access 'arguments' object directly or "
-+				                     "indirectly -> set CREATEARGS"));
-+				DUK_HOBJECT_SET_CREATEARGS((duk_hobject *) h_res);
-+			}
-+		}
-+	} else if (func->is_eval && func->is_strict) {
-+		DUK_DDD(DUK_DDDPRINT("strict eval code -> set NEWENV"));
-+		DUK_HOBJECT_SET_NEWENV((duk_hobject *) h_res);
-+	} else {
-+		/* non-strict eval: env is caller's env or global env (direct vs. indirect call)
-+		 * global code: env is is global env
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("non-strict eval code or global code -> no NEWENV"));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_NEWENV((duk_hobject *) h_res));
-+	}
-+
-+	if (func->is_function && !func->is_decl && func->h_name != NULL && !force_no_namebind) {
-+		/* Object literal set/get functions have a name (property
-+		 * name) but must not have a lexical name binding, see
-+		 * test-bug-getset-func-name.js.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("function expression with a name -> set NAMEBINDING"));
-+		DUK_HOBJECT_SET_NAMEBINDING((duk_hobject *) h_res);
-+	}
-+
-+	if (func->is_strict) {
-+		DUK_DDD(DUK_DDDPRINT("function is strict -> set STRICT"));
-+		DUK_HOBJECT_SET_STRICT((duk_hobject *) h_res);
-+	}
-+
-+	if (func->is_notail) {
-+		DUK_DDD(DUK_DDDPRINT("function is notail -> set NOTAIL"));
-+		DUK_HOBJECT_SET_NOTAIL((duk_hobject *) h_res);
-+	}
-+
-+	/*
-+	 *  Build function fixed size 'data' buffer, which contains bytecode,
-+	 *  constants, and inner function references.
-+	 *
-+	 *  During the building phase 'data' is reachable but incomplete.
-+	 *  Only incref's occur during building (no refzero or GC happens),
-+	 *  so the building process is atomic.
-+	 */
-+
-+	consts_count = duk_hobject_get_length(comp_ctx->thr, func->h_consts);
-+	funcs_count = duk_hobject_get_length(comp_ctx->thr, func->h_funcs) / 3;
-+	code_count = DUK_HBUFFER_GET_SIZE(func->h_code) / sizeof(duk_compiler_instr);
-+	code_size = code_count * sizeof(duk_instr_t);
-+
-+	data_size = consts_count * sizeof(duk_tval) +
-+	            funcs_count * sizeof(duk_hobject *) +
-+	            code_size;
-+
-+	DUK_DDD(DUK_DDDPRINT("consts_count=%ld, funcs_count=%ld, code_size=%ld -> "
-+	                     "data_size=%ld*%ld + %ld*%ld + %ld = %ld",
-+	                     (long) consts_count, (long) funcs_count, (long) code_size,
-+	                     (long) consts_count, (long) sizeof(duk_tval),
-+	                     (long) funcs_count, (long) sizeof(duk_hobject *),
-+	                     (long) code_size, (long) data_size));
-+
-+	duk_push_fixed_buffer(ctx, data_size);
-+	h_data = (duk_hbuffer_fixed *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(h_data != NULL);
-+
-+	DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, h_res, (duk_hbuffer *) h_data);
-+	DUK_HEAPHDR_INCREF(thr, h_data);
-+
-+	p_const = (duk_tval *) DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data);
-+	for (i = 0; i < consts_count; i++) {
-+		DUK_ASSERT(i <= DUK_UARRIDX_MAX);  /* const limits */
-+		tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_consts, (duk_uarridx_t) i);
-+		DUK_ASSERT(tv != NULL);
-+		DUK_TVAL_SET_TVAL(p_const, tv);
-+		p_const++;
-+		DUK_TVAL_INCREF(thr, tv);  /* may be a string constant */
-+
-+		DUK_DDD(DUK_DDDPRINT("constant: %!T", (duk_tval *) tv));
-+	}
-+
-+	p_func = (duk_hobject **) p_const;
-+	DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, h_res, p_func);
-+	for (i = 0; i < funcs_count; i++) {
-+		duk_hobject *h;
-+		DUK_ASSERT(i * 3 <= DUK_UARRIDX_MAX);  /* func limits */
-+		tv = duk_hobject_find_existing_array_entry_tval_ptr(thr->heap, func->h_funcs, (duk_uarridx_t) (i * 3));
-+		DUK_ASSERT(tv != NULL);
-+		DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+		h = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(h != NULL);
-+		DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(h));
-+		*p_func++ = h;
-+		DUK_HOBJECT_INCREF(thr, h);
-+
-+		DUK_DDD(DUK_DDDPRINT("inner function: %p -> %!iO",
-+		                     (void *) h, (duk_heaphdr *) h));
-+	}
-+
-+	p_instr = (duk_instr_t *) p_func;
-+	DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, h_res, p_instr);
-+
-+	/* copy bytecode instructions one at a time */
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(func->h_code));
-+	q_instr = (duk_compiler_instr *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, func->h_code);
-+	for (i = 0; i < code_count; i++) {
-+		p_instr[i] = q_instr[i].ins;
-+	}
-+	/* Note: 'q_instr' is still used below */
-+
-+	DUK_ASSERT((duk_uint8_t *) (p_instr + code_count) == DUK_HBUFFER_FIXED_GET_DATA_PTR(thr->heap, h_data) + data_size);
-+
-+	duk_pop(ctx);  /* 'data' (and everything in it) is reachable through h_res now */
-+
-+	/*
-+	 *  Init object properties
-+	 *
-+	 *  Properties should be added in decreasing order of access frequency.
-+	 *  (Not very critical for function templates.)
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("init function properties"));
-+
-+	/* [ ... res ] */
-+
-+	/* _Varmap: omitted if function is guaranteed not to do slow path identifier
-+	 * accesses or if it would turn out to be empty of actual register mappings
-+	 * after a cleanup.  When debugging is enabled, we always need the varmap to
-+	 * be able to lookup variables at any point.
-+	 */
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	if (1) {
-+#else
-+	if (func->id_access_slow ||     /* directly uses slow accesses */
-+	    func->may_direct_eval ||    /* may indirectly slow access through a direct eval */
-+	    funcs_count > 0) {          /* has inner functions which may slow access (XXX: this can be optimized by looking at the inner functions) */
-+#endif
-+		duk_int_t num_used;
-+		duk_dup(ctx, func->varmap_idx);
-+		num_used = duk__cleanup_varmap(comp_ctx);
-+		DUK_DDD(DUK_DDDPRINT("cleaned up varmap: %!T (num_used=%ld)",
-+		                     (duk_tval *) duk_get_tval(ctx, -1), (long) num_used));
-+
-+		if (num_used > 0) {
-+			duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARMAP, DUK_PROPDESC_FLAGS_NONE);
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("varmap is empty after cleanup -> no need to add"));
-+			duk_pop(ctx);
-+		}
-+	}
-+
-+	/* _Formals: omitted if function is guaranteed not to need a (non-strict) arguments object */
-+	if (1) {
-+		/* XXX: Add a proper condition.  If formals list is omitted, recheck
-+		 * handling for 'length' in duk_js_push_closure(); it currently relies
-+		 * on _Formals being set.  Removal may need to be conditional to debugging
-+		 * being enabled/disabled too.
-+		 */
-+		duk_dup(ctx, func->argnames_idx);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS, DUK_PROPDESC_FLAGS_NONE);
-+	}
-+
-+	/* name */
-+	if (func->h_name) {
-+		duk_push_hstring(ctx, func->h_name);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);
-+	}
-+
-+	/* _Source */
-+#if defined(DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY)
-+	if (0) {
-+		/* XXX: Currently function source code is not stored, as it is not
-+		 * required by the standard.  Source code should not be stored by
-+		 * default (user should enable it explicitly), and the source should
-+		 * probably be compressed with a trivial text compressor; average
-+		 * compression of 20-30% is quite easy to achieve even with a trivial
-+		 * compressor (RLE + backwards lookup).
-+		 *
-+		 * Debugging needs source code to be useful: sometimes input code is
-+		 * not found in files as it may be generated and then eval()'d, given
-+		 * by dynamic C code, etc.
-+		 *
-+		 * Other issues:
-+		 *
-+		 *   - Need tokenizer indices for start and end to substring
-+		 *   - Always normalize function declaration part?
-+		 *   - If we keep _Formals, only need to store body
-+		 */
-+
-+		/*
-+		 *  For global or eval code this is straightforward.  For functions
-+		 *  created with the Function constructor we only get the source for
-+		 *  the body and must manufacture the "function ..." part.
-+		 *
-+		 *  For instance, for constructed functions (v8):
-+		 *
-+		 *    > a = new Function("foo", "bar", "print(foo)");
-+		 *    [Function]
-+		 *    > a.toString()
-+		 *    'function anonymous(foo,bar) {\nprint(foo)\n}'
-+		 *
-+		 *  Similarly for e.g. getters (v8):
-+		 *
-+		 *    > x = { get a(foo,bar) { print(foo); } }
-+		 *    { a: [Getter] }
-+		 *    > Object.getOwnPropertyDescriptor(x, 'a').get.toString()
-+		 *    'function a(foo,bar) { print(foo); }'
-+		 */
-+
-+#if 0
-+		duk_push_string(ctx, "XXX");
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_SOURCE, DUK_PROPDESC_FLAGS_NONE);
-+#endif
-+	}
-+#endif  /* DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY */
-+
-+	/* _Pc2line */
-+#if defined(DUK_USE_PC2LINE)
-+	if (1) {
-+		/*
-+		 *  Size-optimized pc->line mapping.
-+		 */
-+
-+		DUK_ASSERT(code_count <= DUK_COMPILER_MAX_BYTECODE_LENGTH);
-+		duk_hobject_pc2line_pack(thr, q_instr, (duk_uint_fast32_t) code_count);  /* -> pushes fixed buffer */
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_NONE);
-+
-+		/* XXX: if assertions enabled, walk through all valid PCs
-+		 * and check line mapping.
-+		 */
-+	}
-+#endif  /* DUK_USE_PC2LINE */
-+
-+	/* fileName */
-+	if (comp_ctx->h_filename) {
-+		/*
-+		 *  Source filename (or equivalent), for identifying thrown errors.
-+		 */
-+
-+		duk_push_hstring(ctx, comp_ctx->h_filename);
-+		duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_NONE);
-+	}
-+
-+	/*
-+	 *  Init remaining result fields
-+	 *
-+	 *  'nregs' controls how large a register frame is allocated.
-+	 *
-+	 *  'nargs' controls how many formal arguments are written to registers:
-+	 *  r0, ... r(nargs-1).  The remaining registers are initialized to
-+	 *  undefined.
-+	 */
-+
-+	DUK_ASSERT(func->temp_max >= 0);
-+	h_res->nregs = func->temp_max;
-+	h_res->nargs = duk_hobject_get_length(thr, func->h_argnames);
-+	DUK_ASSERT(h_res->nregs >= h_res->nargs);  /* pass2 allocation handles this */
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	h_res->start_line = (duk_uint32_t) func->min_line;
-+	h_res->end_line = (duk_uint32_t) func->max_line;
-+#endif
-+
-+	DUK_DD(DUK_DDPRINT("converted function: %!ixT",
-+	                   (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/*
-+	 *  Compact the function template.
-+	 */
-+
-+	duk_compact(ctx, -1);
-+
-+	/*
-+	 *  Debug dumping
-+	 */
-+
-+#ifdef DUK_USE_DDDPRINT
-+	{
-+		duk_hcompiledfunction *h;
-+		duk_instr_t *p, *p_start, *p_end;
-+
-+		h = (duk_hcompiledfunction *) duk_get_hobject(ctx, -1);
-+		p_start = (duk_instr_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, h);
-+		p_end = (duk_instr_t *) DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, h);
-+
-+		p = p_start;
-+		while (p < p_end) {
-+			DUK_DDD(DUK_DDDPRINT("BC %04ld: %!I        ; 0x%08lx op=%ld (%!C) a=%ld b=%ld c=%ld",
-+			                     (long) (p - p_start),
-+			                     (duk_instr_t) (*p),
-+			                     (unsigned long) (*p),
-+			                     (long) DUK_DEC_OP(*p),
-+			                     (long) DUK_DEC_OP(*p),
-+			                     (long) DUK_DEC_A(*p),
-+			                     (long) DUK_DEC_B(*p),
-+			                     (long) DUK_DEC_C(*p)));
-+			p++;
-+		}
-+	}
-+#endif
-+}
-+
-+/*
-+ *  Code emission helpers
-+ *
-+ *  Some emission helpers understand the range of target and source reg/const
-+ *  values and automatically emit shuffling code if necessary.  This is the
-+ *  case when the slot in question (A, B, C) is used in the standard way and
-+ *  for opcodes the emission helpers explicitly understand (like DUK_OP_CALL).
-+ *
-+ *  The standard way is that:
-+ *    - slot A is a target register
-+ *    - slot B is a source register/constant
-+ *    - slot C is a source register/constant
-+ *
-+ *  If a slot is used in a non-standard way the caller must indicate this
-+ *  somehow.  If a slot is used as a target instead of a source (or vice
-+ *  versa), this can be indicated with a flag to trigger proper shuffling
-+ *  (e.g. DUK__EMIT_FLAG_B_IS_TARGET).  If the value in the slot is not
-+ *  register/const related at all, the caller must ensure that the raw value
-+ *  fits into the corresponding slot so as to not trigger shuffling.  The
-+ *  caller must set a "no shuffle" flag to ensure compilation fails if
-+ *  shuffling were to be triggered because of an internal error.
-+ *
-+ *  For slots B and C the raw slot size is 9 bits but one bit is reserved for
-+ *  the reg/const indicator.  To use the full 9-bit range for a raw value,
-+ *  shuffling must be disabled with the DUK__EMIT_FLAG_NO_SHUFFLE_{B,C} flag.
-+ *  Shuffling is only done for A, B, and C slots, not the larger BC or ABC slots.
-+ *
-+ *  There is call handling specific understanding in the A-B-C emitter to
-+ *  convert call setup and call instructions into indirect ones if necessary.
-+ */
-+
-+/* Code emission flags, passed in the 'opcode' field.  Opcode + flags
-+ * fit into 16 bits for now, so use duk_small_uint.t.
-+ */
-+#define DUK__EMIT_FLAG_NO_SHUFFLE_A      (1 << 8)
-+#define DUK__EMIT_FLAG_NO_SHUFFLE_B      (1 << 9)
-+#define DUK__EMIT_FLAG_NO_SHUFFLE_C      (1 << 10)
-+#define DUK__EMIT_FLAG_A_IS_SOURCE       (1 << 11)  /* slot A is a source (default: target) */
-+#define DUK__EMIT_FLAG_B_IS_TARGET       (1 << 12)  /* slot B is a target (default: source) */
-+#define DUK__EMIT_FLAG_C_IS_TARGET       (1 << 13)  /* slot C is a target (default: source) */
-+#define DUK__EMIT_FLAG_B_IS_TARGETSOURCE (1 << 14)  /* slot B is both a target and a source (used by extraops like DUK_EXTRAOP_INSTOF */
-+#define DUK__EMIT_FLAG_RESERVE_JUMPSLOT  (1 << 15)  /* reserve a jumpslot after instr before target spilling, used for NEXTENUM */
-+
-+/* XXX: clarify on when and where DUK__CONST_MARKER is allowed */
-+/* XXX: opcode specific assertions on when consts are allowed */
-+
-+/* XXX: macro smaller than call? */
-+DUK_LOCAL duk_int_t duk__get_current_pc(duk_compiler_ctx *comp_ctx) {
-+	return (duk_int_t) (DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_code) / sizeof(duk_compiler_instr));
-+}
-+
-+DUK_LOCAL duk_compiler_instr *duk__get_instr_ptr(duk_compiler_ctx *comp_ctx, duk_int_t pc) {
-+	duk_compiler_func *f = &comp_ctx->curr_func;
-+	duk_uint8_t *p;
-+	duk_compiler_instr *code_begin, *code_end;
-+
-+	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, f->h_code);
-+	code_begin = (duk_compiler_instr *) p;
-+	code_end = (duk_compiler_instr *) (p + DUK_HBUFFER_GET_SIZE(f->h_code));
-+	DUK_UNREF(code_end);
-+
-+	DUK_ASSERT(pc >= 0);
-+	DUK_ASSERT((duk_size_t) pc < (duk_size_t) (code_end - code_begin));
-+
-+	return code_begin + pc;
-+}
-+
-+/* emit instruction; could return PC but that's not needed in the majority
-+ * of cases.
-+ */
-+DUK_LOCAL void duk__emit(duk_compiler_ctx *comp_ctx, duk_instr_t ins) {
-+	duk_hbuffer_dynamic *h;
-+#if defined(DUK_USE_PC2LINE)
-+	duk_int_t line;
-+#endif
-+	duk_compiler_instr instr;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__emit: 0x%08lx curr_token.start_line=%ld prev_token.start_line=%ld pc=%ld --> %!I",
-+	                     (unsigned long) ins,
-+	                     (long) comp_ctx->curr_token.start_line,
-+	                     (long) comp_ctx->prev_token.start_line,
-+	                     (long) duk__get_current_pc(comp_ctx),
-+	                     (duk_instr_t) ins));
-+
-+	h = comp_ctx->curr_func.h_code;
-+#if defined(DUK_USE_PC2LINE)
-+	/* The line number tracking is a bit inconsistent right now, which
-+	 * affects debugger accuracy.  Mostly call sites emit opcodes when
-+	 * they have parsed a token (say a terminating semicolon) and called
-+	 * duk__advance().  In this case the line number of the previous
-+	 * token is the most accurate one (except in prologue where
-+	 * prev_token.start_line is 0).  This is probably not 100% correct
-+	 * right now.
-+	 */
-+	/* approximation, close enough */
-+	line = comp_ctx->prev_token.start_line;
-+	if (line == 0) {
-+		line = comp_ctx->curr_token.start_line;
-+	}
-+#endif
-+
-+	instr.ins = ins;
-+#if defined(DUK_USE_PC2LINE)
-+	instr.line = line;
-+#endif
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	if (line < comp_ctx->curr_func.min_line) {
-+		comp_ctx->curr_func.min_line = line;
-+	}
-+	if (line > comp_ctx->curr_func.max_line) {
-+		comp_ctx->curr_func.max_line = line;
-+	}
-+#endif
-+
-+	/* Limit checks for bytecode byte size and line number. */
-+#if defined(DUK_USE_PC2LINE) && defined(DUK_USE_ESBC_LIMITS)
-+#if defined(DUK_USE_BUFLEN16)
-+	/* Buffer length is bounded to 0xffff automatically, avoid compile warning. */
-+	if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER)) {
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_BYTECODE_LIMIT);
-+	}
-+#else
-+	if (DUK_UNLIKELY(line > DUK_USE_ESBC_MAX_LINENUMBER ||
-+	                 DUK_HBUFFER_GET_SIZE((duk_hbuffer *) h) > DUK_USE_ESBC_MAX_BYTES)) {
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_BYTECODE_LIMIT);
-+	}
-+#endif
-+#endif
-+
-+	duk_hbuffer_append_bytes(comp_ctx->thr, h, (duk_uint8_t *) &instr, sizeof(instr));
-+}
-+
-+/* Update function min/max line from current token.  Needed to improve
-+ * function line range information for debugging, so that e.g. opening
-+ * curly brace is covered by line range even when no opcodes are emitted
-+ * for the line containing the brace.
-+ */
-+DUK_LOCAL void duk__update_lineinfo_currtoken(duk_compiler_ctx *comp_ctx) {
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	duk_int_t line;
-+
-+	line = comp_ctx->curr_token.start_line;
-+	if (line == 0) {
-+		return;
-+	}
-+	if (line < comp_ctx->curr_func.min_line) {
-+		comp_ctx->curr_func.min_line = line;
-+	}
-+	if (line > comp_ctx->curr_func.max_line) {
-+		comp_ctx->curr_func.max_line = line;
-+	}
-+#else
-+	DUK_UNREF(comp_ctx);
-+#endif
-+}
-+
-+#if 0 /* unused */
-+DUK_LOCAL void duk__emit_op_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t op) {
-+	duk__emit(comp_ctx, DUK_ENC_OP_ABC(op, 0));
-+}
-+#endif
-+
-+/* Important main primitive. */
-+DUK_LOCAL void duk__emit_a_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b, duk_regconst_t c) {
-+	duk_instr_t ins = 0;
-+	duk_int_t a_out = -1;
-+	duk_int_t b_out = -1;
-+	duk_int_t c_out = -1;
-+	duk_int_t tmp;
-+
-+	DUK_DDD(DUK_DDDPRINT("emit: op_flags=%04lx, a=%ld, b=%ld, c=%ld",
-+	                     (unsigned long) op_flags, (long) a, (long) b, (long) c));
-+
-+	/* We could rely on max temp/const checks: if they don't exceed BC
-+	 * limit, nothing here can either (just asserts would be enough).
-+	 * Currently we check for the limits, which provides additional
-+	 * protection against creating invalid bytecode due to compiler
-+	 * bugs.
-+	 */
-+
-+	DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN);  /* unsigned */
-+	DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX);
-+
-+	/* Input shuffling happens before the actual operation, while output
-+	 * shuffling happens afterwards.  Output shuffling decisions are still
-+	 * made at the same time to reduce branch clutter; output shuffle decisions
-+	 * are recorded into X_out variables.
-+	 */
-+
-+	/* Slot A */
-+
-+#if defined(DUK_USE_SHUFFLE_TORTURE)
-+	if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) {
-+#else
-+	if (a <= DUK_BC_A_MAX) {
-+#endif
-+		;
-+	} else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) {
-+		DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but shuffle prohibited, a: %ld", (long) a));
-+		goto error_outofregs;
-+	} else if (a <= DUK_BC_BC_MAX) {
-+		comp_ctx->curr_func.needs_shuffle = 1;
-+		tmp = comp_ctx->curr_func.shuffle1;
-+		if (op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) {
-+			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a));
-+		} else {
-+			duk_small_int_t op = op_flags & 0xff;
-+			if (op == DUK_OP_CSVAR || op == DUK_OP_CSREG || op == DUK_OP_CSPROP) {
-+				/* Special handling for call setup instructions.  The target
-+				 * is expressed indirectly, but there is no output shuffling.
-+				 */
-+				DUK_ASSERT((op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) == 0);
-+				duk__emit_load_int32_noshuffle(comp_ctx, tmp, a);
-+				DUK_ASSERT(DUK_OP_CSVARI == DUK_OP_CSVAR + 1);
-+				DUK_ASSERT(DUK_OP_CSREGI == DUK_OP_CSREG + 1);
-+				DUK_ASSERT(DUK_OP_CSPROPI == DUK_OP_CSPROP + 1);
-+				op_flags++;  /* indirect opcode follows direct */
-+			} else {
-+				/* Output shuffle needed after main operation */
-+				a_out = a;
-+			}
-+		}
-+		a = tmp;
-+	} else {
-+		DUK_D(DUK_DPRINT("out of regs: 'a' (reg) needs shuffling but does not fit into BC, a: %ld", (long) a));
-+		goto error_outofregs;
-+	}
-+
-+	/* Slot B */
-+
-+	if (b & DUK__CONST_MARKER) {
-+		DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) == 0);
-+		DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0);
-+		DUK_ASSERT((op_flags & 0xff) != DUK_OP_CALL);
-+		DUK_ASSERT((op_flags & 0xff) != DUK_OP_NEW);
-+		b = b & ~DUK__CONST_MARKER;
-+#if defined(DUK_USE_SHUFFLE_TORTURE)
-+		if (0) {
-+#else
-+		if (b <= 0xff) {
-+#endif
-+			ins |= DUK_ENC_OP_A_B_C(0, 0, 0x100, 0);  /* const flag for B */
-+		} else if (b <= DUK_BC_BC_MAX) {
-+			comp_ctx->curr_func.needs_shuffle = 1;
-+			tmp = comp_ctx->curr_func.shuffle2;
-+			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, b));
-+			b = tmp;
-+		} else {
-+			DUK_D(DUK_DPRINT("out of regs: 'b' (const) needs shuffling but does not fit into BC, b: %ld", (long) b));
-+			goto error_outofregs;
-+		}
-+	} else {
-+#if defined(DUK_USE_SHUFFLE_TORTURE)
-+		if (b <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B)) {
-+#else
-+		if (b <= 0xff) {
-+#endif
-+			;
-+		} else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_B) {
-+			if (b > DUK_BC_B_MAX) {
-+				/* Note: 0xff != DUK_BC_B_MAX */
-+				DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but shuffle prohibited, b: %ld", (long) b));
-+				goto error_outofregs;
-+			}
-+		} else if (b <= DUK_BC_BC_MAX) {
-+			comp_ctx->curr_func.needs_shuffle = 1;
-+			tmp = comp_ctx->curr_func.shuffle2;
-+			if (op_flags & DUK__EMIT_FLAG_B_IS_TARGET) {
-+				/* Output shuffle needed after main operation */
-+				b_out = b;
-+			}
-+			if (!(op_flags & DUK__EMIT_FLAG_B_IS_TARGET) || (op_flags & DUK__EMIT_FLAG_B_IS_TARGETSOURCE)) {
-+				duk_small_int_t op = op_flags & 0xff;
-+				if (op == DUK_OP_CALL || op == DUK_OP_NEW ||
-+				    op == DUK_OP_MPUTOBJ || op == DUK_OP_MPUTARR) {
-+					/* Special handling for CALL/NEW/MPUTOBJ/MPUTARR shuffling.
-+					 * For each, slot B identifies the first register of a range
-+					 * of registers, so normal shuffling won't work.  Instead,
-+					 * an indirect version of the opcode is used.
-+					 */
-+					DUK_ASSERT((op_flags & DUK__EMIT_FLAG_B_IS_TARGET) == 0);
-+					duk__emit_load_int32_noshuffle(comp_ctx, tmp, b);
-+					DUK_ASSERT(DUK_OP_CALLI == DUK_OP_CALL + 1);
-+					DUK_ASSERT(DUK_OP_NEWI == DUK_OP_NEW + 1);
-+					DUK_ASSERT(DUK_OP_MPUTOBJI == DUK_OP_MPUTOBJ + 1);
-+					DUK_ASSERT(DUK_OP_MPUTARRI == DUK_OP_MPUTARR + 1);
-+					op_flags++;  /* indirect opcode follows direct */
-+				} else {
-+					duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, b));
-+				}
-+			}
-+			b = tmp;
-+		} else {
-+			DUK_D(DUK_DPRINT("out of regs: 'b' (reg) needs shuffling but does not fit into BC, b: %ld", (long) b));
-+			goto error_outofregs;
-+		}
-+	}
-+
-+	/* Slot C */
-+
-+	if (c & DUK__CONST_MARKER) {
-+		DUK_ASSERT((op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) == 0);
-+		DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0);
-+		c = c & ~DUK__CONST_MARKER;
-+#if defined(DUK_USE_SHUFFLE_TORTURE)
-+		if (0) {
-+#else
-+		if (c <= 0xff) {
-+#endif
-+			ins |= DUK_ENC_OP_A_B_C(0, 0, 0, 0x100);  /* const flag for C */
-+		} else if (c <= DUK_BC_BC_MAX) {
-+			comp_ctx->curr_func.needs_shuffle = 1;
-+			tmp = comp_ctx->curr_func.shuffle3;
-+			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDCONST, tmp, c));
-+			c = tmp;
-+		} else {
-+			DUK_D(DUK_DPRINT("out of regs: 'c' (const) needs shuffling but does not fit into BC, c: %ld", (long) c));
-+			goto error_outofregs;
-+		}
-+	} else {
-+#if defined(DUK_USE_SHUFFLE_TORTURE)
-+		if (c <= 0xff && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C)) {
-+#else
-+		if (c <= 0xff) {
-+#endif
-+			;
-+		} else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_C) {
-+			if (c > DUK_BC_C_MAX) {
-+				/* Note: 0xff != DUK_BC_C_MAX */
-+				DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but shuffle prohibited, c: %ld", (long) c));
-+				goto error_outofregs;
-+			}
-+		} else if (c <= DUK_BC_BC_MAX) {
-+			comp_ctx->curr_func.needs_shuffle = 1;
-+			tmp = comp_ctx->curr_func.shuffle3;
-+			if (op_flags & DUK__EMIT_FLAG_C_IS_TARGET) {
-+				/* Output shuffle needed after main operation */
-+				c_out = c;
-+			} else {
-+				duk_small_int_t op = op_flags & 0xff;
-+				if (op == DUK_OP_EXTRA &&
-+				    (a == DUK_EXTRAOP_INITGET || a == DUK_EXTRAOP_INITSET)) {
-+					/* Special shuffling for INITGET/INITSET, where slot C
-+					 * identifies a register pair and cannot be shuffled
-+					 * normally.  Use an indirect variant instead.
-+					 */
-+					DUK_ASSERT((op_flags & DUK__EMIT_FLAG_C_IS_TARGET) == 0);
-+					duk__emit_load_int32_noshuffle(comp_ctx, tmp, c);
-+					DUK_ASSERT(DUK_EXTRAOP_INITGETI == DUK_EXTRAOP_INITGET + 1);
-+					DUK_ASSERT(DUK_EXTRAOP_INITSETI == DUK_EXTRAOP_INITSET + 1);
-+					a++;  /* indirect opcode follows direct */
-+				} else {
-+					duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, c));
-+				}
-+			}
-+			c = tmp;
-+		} else {
-+			DUK_D(DUK_DPRINT("out of regs: 'c' (reg) needs shuffling but does not fit into BC, c: %ld", (long) c));
-+			goto error_outofregs;
-+		}
-+	}
-+
-+	/* Main operation */
-+
-+	DUK_ASSERT_DISABLE(a >= DUK_BC_A_MIN);  /* unsigned */
-+	DUK_ASSERT(a <= DUK_BC_A_MAX);
-+	DUK_ASSERT_DISABLE(b >= DUK_BC_B_MIN);  /* unsigned */
-+	DUK_ASSERT(b <= DUK_BC_B_MAX);
-+	DUK_ASSERT_DISABLE(c >= DUK_BC_C_MIN);  /* unsigned */
-+	DUK_ASSERT(c <= DUK_BC_C_MAX);
-+
-+	ins |= DUK_ENC_OP_A_B_C(op_flags & 0xff, a, b, c);
-+	duk__emit(comp_ctx, ins);
-+
-+	/* NEXTENUM needs a jump slot right after the main instruction.
-+	 * When the JUMP is taken, output spilling is not needed so this
-+	 * workaround is possible.  The jump slot PC is exceptionally
-+	 * plumbed through comp_ctx to minimize call sites.
-+	 */
-+	if (op_flags & DUK__EMIT_FLAG_RESERVE_JUMPSLOT) {
-+		comp_ctx->emit_jumpslot_pc = duk__get_current_pc(comp_ctx);
-+		duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0);
-+	}
-+
-+	/* Output shuffling: only one output register is realistically possible.
-+	 *
-+	 * (Zero would normally be an OK marker value: if the target register
-+	 * was zero, it would never be shuffled.  But with DUK_USE_SHUFFLE_TORTURE
-+	 * this is no longer true, so use -1 as a marker instead.)
-+	 */
-+
-+	if (a_out >= 0) {
-+		DUK_ASSERT(b_out < 0);
-+		DUK_ASSERT(c_out < 0);
-+		duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, a, a_out));
-+	} else if (b_out >= 0) {
-+		DUK_ASSERT(a_out < 0);
-+		DUK_ASSERT(c_out < 0);
-+		duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, b, b_out));
-+	} else if (c_out >= 0) {
-+		DUK_ASSERT(b_out < 0);
-+		DUK_ASSERT(c_out < 0);
-+		duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, c, c_out));
-+	}
-+
-+	return;
-+
-+ error_outofregs:
-+	DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REG_LIMIT);
-+}
-+
-+DUK_LOCAL void duk__emit_a_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t b) {
-+	duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, b, 0);
-+}
-+
-+#if 0  /* unused */
-+DUK_LOCAL void duk__emit_a(duk_compiler_ctx *comp_ctx, int op_flags, int a) {
-+	duk__emit_a_b_c(comp_ctx, op_flags | DUK__EMIT_FLAG_NO_SHUFFLE_B | DUK__EMIT_FLAG_NO_SHUFFLE_C, a, 0, 0);
-+}
-+#endif
-+
-+DUK_LOCAL void duk__emit_a_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op_flags, duk_regconst_t a, duk_regconst_t bc) {
-+	duk_instr_t ins;
-+	duk_int_t tmp;
-+
-+	/* allow caller to give a const number with the DUK__CONST_MARKER */
-+	bc = bc & (~DUK__CONST_MARKER);
-+
-+	DUK_ASSERT_DISABLE((op_flags & 0xff) >= DUK_BC_OP_MIN);  /* unsigned */
-+	DUK_ASSERT((op_flags & 0xff) <= DUK_BC_OP_MAX);
-+	DUK_ASSERT_DISABLE(bc >= DUK_BC_BC_MIN);  /* unsigned */
-+	DUK_ASSERT(bc <= DUK_BC_BC_MAX);
-+	DUK_ASSERT((bc & DUK__CONST_MARKER) == 0);
-+
-+	if (bc <= DUK_BC_BC_MAX) {
-+		;
-+	} else {
-+		/* No BC shuffling now. */
-+		goto error_outofregs;
-+	}
-+
-+#if defined(DUK_USE_SHUFFLE_TORTURE)
-+	if (a <= DUK_BC_A_MAX && (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A)) {
-+#else
-+	if (a <= DUK_BC_A_MAX) {
-+#endif
-+		ins = DUK_ENC_OP_A_BC(op_flags & 0xff, a, bc);
-+		duk__emit(comp_ctx, ins);
-+	} else if (op_flags & DUK__EMIT_FLAG_NO_SHUFFLE_A) {
-+		goto error_outofregs;
-+	} else if (a <= DUK_BC_BC_MAX) {
-+		comp_ctx->curr_func.needs_shuffle = 1;
-+		tmp = comp_ctx->curr_func.shuffle1;
-+		ins = DUK_ENC_OP_A_BC(op_flags & 0xff, tmp, bc);
-+		if (op_flags & DUK__EMIT_FLAG_A_IS_SOURCE) {
-+			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_LDREG, tmp, a));
-+			duk__emit(comp_ctx, ins);
-+		} else {
-+			duk__emit(comp_ctx, ins);
-+			duk__emit(comp_ctx, DUK_ENC_OP_A_BC(DUK_OP_STREG, tmp, a));
-+		}
-+	} else {
-+		goto error_outofregs;
-+	}
-+	return;
-+
-+ error_outofregs:
-+	DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REG_LIMIT);
-+}
-+
-+DUK_LOCAL void duk__emit_abc(duk_compiler_ctx *comp_ctx, duk_small_uint_t op, duk_regconst_t abc) {
-+	duk_instr_t ins;
-+
-+	DUK_ASSERT_DISABLE(op >= DUK_BC_OP_MIN);  /* unsigned */
-+	DUK_ASSERT(op <= DUK_BC_OP_MAX);
-+	DUK_ASSERT_DISABLE(abc >= DUK_BC_ABC_MIN);  /* unsigned */
-+	DUK_ASSERT(abc <= DUK_BC_ABC_MAX);
-+	DUK_ASSERT((abc & DUK__CONST_MARKER) == 0);
-+
-+	if (abc <= DUK_BC_ABC_MAX) {
-+		;
-+	} else {
-+		goto error_outofregs;
-+	}
-+	ins = DUK_ENC_OP_ABC(op, abc);
-+	DUK_DDD(DUK_DDDPRINT("duk__emit_abc: 0x%08lx line=%ld pc=%ld op=%ld (%!C) abc=%ld (%!I)",
-+	                     (unsigned long) ins, (long) comp_ctx->curr_token.start_line,
-+	                     (long) duk__get_current_pc(comp_ctx), (long) op, (long) op,
-+	                     (long) abc, (duk_instr_t) ins));
-+	duk__emit(comp_ctx, ins);
-+	return;
-+
-+ error_outofregs:
-+	DUK_ERROR(comp_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REG_LIMIT);
-+}
-+
-+DUK_LOCAL void duk__emit_extraop_b_c(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b, duk_regconst_t c) {
-+	DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
-+	DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
-+	/* Setting "no shuffle A" is covered by the assert, but it's needed
-+	 * with DUK_USE_SHUFFLE_TORTURE.
-+	 */
-+	duk__emit_a_b_c(comp_ctx,
-+	                DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | (extraop_flags & ~0xff),  /* transfer flags */
-+	                extraop_flags & 0xff,
-+	                b,
-+	                c);
-+}
-+
-+DUK_LOCAL void duk__emit_extraop_b(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags, duk_regconst_t b) {
-+	DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
-+	DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
-+	/* Setting "no shuffle A" is covered by the assert, but it's needed
-+	 * with DUK_USE_SHUFFLE_TORTURE.
-+	 */
-+	duk__emit_a_b_c(comp_ctx,
-+	                DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | (extraop_flags & ~0xff),  /* transfer flags */
-+	                extraop_flags & 0xff,
-+	                b,
-+	                0);
-+}
-+
-+DUK_LOCAL void duk__emit_extraop_bc(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop, duk_regconst_t bc) {
-+	DUK_ASSERT_DISABLE(extraop >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
-+	DUK_ASSERT(extraop <= DUK_BC_EXTRAOP_MAX);
-+	/* Setting "no shuffle A" is covered by the assert, but it's needed
-+	 * with DUK_USE_SHUFFLE_TORTURE.
-+	 */
-+	duk__emit_a_bc(comp_ctx,
-+	               DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A,
-+	               extraop,
-+	               bc);
-+}
-+
-+DUK_LOCAL void duk__emit_extraop_only(duk_compiler_ctx *comp_ctx, duk_small_uint_t extraop_flags) {
-+	DUK_ASSERT_DISABLE((extraop_flags & 0xff) >= DUK_BC_EXTRAOP_MIN);  /* unsigned */
-+	DUK_ASSERT((extraop_flags & 0xff) <= DUK_BC_EXTRAOP_MAX);
-+	/* Setting "no shuffle A" is covered by the assert, but it's needed
-+	 * with DUK_USE_SHUFFLE_TORTURE.
-+	 */
-+	duk__emit_a_b_c(comp_ctx,
-+	                DUK_OP_EXTRA | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_B |
-+	                    DUK__EMIT_FLAG_NO_SHUFFLE_C | (extraop_flags & ~0xff),  /* transfer flags */
-+	                extraop_flags & 0xff,
-+	                0,
-+	                0);
-+}
-+
-+DUK_LOCAL void duk__emit_load_int32_raw(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val, duk_small_uint_t op_flags) {
-+	/* XXX: Shuffling support could be implemented here so that LDINT+LDINTX
-+	 * would only shuffle once (instead of twice).  The current code works
-+	 * though, and has a smaller compiler footprint.
-+	 */
-+
-+	if ((val >= (duk_int32_t) DUK_BC_BC_MIN - (duk_int32_t) DUK_BC_LDINT_BIAS) &&
-+	    (val <= (duk_int32_t) DUK_BC_BC_MAX - (duk_int32_t) DUK_BC_LDINT_BIAS)) {
-+		DUK_DDD(DUK_DDDPRINT("emit LDINT to reg %ld for %ld", (long) reg, (long) val));
-+		duk__emit_a_bc(comp_ctx, DUK_OP_LDINT | op_flags, reg, (duk_regconst_t) (val + (duk_int32_t) DUK_BC_LDINT_BIAS));
-+	} else {
-+		duk_int32_t hi = val >> DUK_BC_LDINTX_SHIFT;
-+		duk_int32_t lo = val & ((((duk_int32_t) 1) << DUK_BC_LDINTX_SHIFT) - 1);
-+		DUK_ASSERT(lo >= 0);
-+		DUK_DDD(DUK_DDDPRINT("emit LDINT+LDINTX to reg %ld for %ld -> hi %ld, lo %ld",
-+		                     (long) reg, (long) val, (long) hi, (long) lo));
-+		duk__emit_a_bc(comp_ctx, DUK_OP_LDINT | op_flags, reg, (duk_regconst_t) (hi + (duk_int32_t) DUK_BC_LDINT_BIAS));
-+		duk__emit_a_bc(comp_ctx, DUK_OP_LDINTX | op_flags, reg, (duk_regconst_t) lo);
-+	}
-+}
-+
-+DUK_LOCAL void duk__emit_load_int32(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) {
-+	duk__emit_load_int32_raw(comp_ctx, reg, val, 0 /*op_flags*/);
-+}
-+
-+#if defined(DUK_USE_SHUFFLE_TORTURE)
-+/* Used by duk__emit*() calls so that we don't shuffle the loadints that
-+ * are needed to handle indirect opcodes.
-+ */
-+DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) {
-+	duk__emit_load_int32_raw(comp_ctx, reg, val, DUK__EMIT_FLAG_NO_SHUFFLE_A /*op_flags*/);
-+}
-+#else
-+DUK_LOCAL void duk__emit_load_int32_noshuffle(duk_compiler_ctx *comp_ctx, duk_reg_t reg, duk_int32_t val) {
-+	/* When torture not enabled, can just use the same helper because
-+	 * 'reg' won't get spilled.
-+	 */
-+	DUK_ASSERT(reg <= DUK_BC_A_MAX);
-+	duk__emit_load_int32(comp_ctx, reg, val);
-+}
-+#endif
-+
-+DUK_LOCAL void duk__emit_jump(duk_compiler_ctx *comp_ctx, duk_int_t target_pc) {
-+	duk_hbuffer_dynamic *h;
-+	duk_int_t curr_pc;
-+	duk_int_t offset;
-+
-+	h = comp_ctx->curr_func.h_code;
-+	curr_pc = (duk_int_t) (DUK_HBUFFER_GET_SIZE(h) / sizeof(duk_compiler_instr));
-+	offset = (duk_int_t) target_pc - (duk_int_t) curr_pc - 1;
-+	DUK_ASSERT(offset + DUK_BC_JUMP_BIAS >= DUK_BC_ABC_MIN);
-+	DUK_ASSERT(offset + DUK_BC_JUMP_BIAS <= DUK_BC_ABC_MAX);
-+	duk__emit_abc(comp_ctx, DUK_OP_JUMP, (duk_regconst_t) (offset + DUK_BC_JUMP_BIAS));
-+}
-+
-+DUK_LOCAL duk_int_t duk__emit_jump_empty(duk_compiler_ctx *comp_ctx) {
-+	duk_int_t ret;
-+
-+	ret = duk__get_current_pc(comp_ctx);  /* useful for patching jumps later */
-+	duk__emit_abc(comp_ctx, DUK_OP_JUMP, 0);
-+	return ret;
-+}
-+
-+/* Insert an empty jump in the middle of code emitted earlier.  This is
-+ * currently needed for compiling for-in.
-+ */
-+DUK_LOCAL void duk__insert_jump_entry(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) {
-+	duk_hbuffer_dynamic *h;
-+#if defined(DUK_USE_PC2LINE)
-+	duk_int_t line;
-+#endif
-+	duk_compiler_instr instr;
-+	duk_size_t offset;
-+
-+	h = comp_ctx->curr_func.h_code;
-+#if defined(DUK_USE_PC2LINE)
-+	line = comp_ctx->curr_token.start_line;  /* approximation, close enough */
-+#endif
-+
-+	instr.ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, 0);
-+#if defined(DUK_USE_PC2LINE)
-+	instr.line = line;
-+#endif
-+
-+	offset = jump_pc * sizeof(duk_compiler_instr);
-+
-+	duk_hbuffer_insert_bytes(comp_ctx->thr, h, offset, (duk_uint8_t *) &instr, sizeof(instr));
-+}
-+
-+/* Does not assume that jump_pc contains a DUK_OP_JUMP previously; this is intentional
-+ * to allow e.g. an INVALID opcode be overwritten with a JUMP (label management uses this).
-+ */
-+DUK_LOCAL void duk__patch_jump(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc, duk_int_t target_pc) {
-+	duk_compiler_instr *instr;
-+	duk_int_t offset;
-+
-+	/* allow negative PCs, behave as a no-op */
-+	if (jump_pc < 0) {
-+		DUK_DDD(DUK_DDDPRINT("duk__patch_jump(): nop call, jump_pc=%ld (<0), target_pc=%ld",
-+		                     (long) jump_pc, (long) target_pc));
-+		return;
-+	}
-+	DUK_ASSERT(jump_pc >= 0);
-+
-+	/* XXX: range assert */
-+	instr = duk__get_instr_ptr(comp_ctx, jump_pc);
-+	DUK_ASSERT(instr != NULL);
-+
-+	/* XXX: range assert */
-+	offset = target_pc - jump_pc - 1;
-+
-+	instr->ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, offset + DUK_BC_JUMP_BIAS);
-+	DUK_DDD(DUK_DDDPRINT("duk__patch_jump(): jump_pc=%ld, target_pc=%ld, offset=%ld",
-+	                     (long) jump_pc, (long) target_pc, (long) offset));
-+}
-+
-+DUK_LOCAL void duk__patch_jump_here(duk_compiler_ctx *comp_ctx, duk_int_t jump_pc) {
-+	duk__patch_jump(comp_ctx, jump_pc, duk__get_current_pc(comp_ctx));
-+}
-+
-+DUK_LOCAL void duk__patch_trycatch(duk_compiler_ctx *comp_ctx, duk_int_t trycatch_pc, duk_regconst_t reg_catch, duk_regconst_t const_varname, duk_small_uint_t flags) {
-+	duk_compiler_instr *instr;
-+
-+	instr = duk__get_instr_ptr(comp_ctx, trycatch_pc);
-+	DUK_ASSERT(instr != NULL);
-+
-+	DUK_ASSERT_DISABLE(flags >= DUK_BC_A_MIN);
-+	DUK_ASSERT(flags <= DUK_BC_A_MAX);
-+
-+	DUK_ASSERT((reg_catch & DUK__CONST_MARKER) == 0);
-+	const_varname = const_varname & (~DUK__CONST_MARKER);
-+	if (reg_catch > DUK_BC_B_MAX || const_varname > DUK_BC_C_MAX) {
-+		/* Catch attempts to use out-of-range reg/const.  Without this
-+		 * check Duktape 0.12.0 could generate invalid code which caused
-+		 * an assert failure on execution.  This error is triggered e.g.
-+		 * for functions with a lot of constants and a try-catch statement.
-+		 * Shuffling or opcode semantics change is needed to fix the issue.
-+		 * See: test-bug-trycatch-many-constants.js.
-+		 */
-+		DUK_D(DUK_DPRINT("failed to patch trycatch: flags=%ld, reg_catch=%ld, const_varname=%ld (0x%08lx)",
-+		                 (long) flags, (long) reg_catch, (long) const_varname, (long) const_varname));
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REG_LIMIT);
-+	}
-+
-+	instr->ins = DUK_ENC_OP_A_B_C(DUK_OP_TRYCATCH, flags, reg_catch, const_varname);
-+}
-+
-+DUK_LOCAL void duk__emit_if_false_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst) {
-+	duk__emit_a_b_c(comp_ctx,
-+	                DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C,
-+	                0 /*false*/,
-+	                regconst,
-+	                0 /*unused*/);
-+}
-+
-+DUK_LOCAL void duk__emit_if_true_skip(duk_compiler_ctx *comp_ctx, duk_regconst_t regconst) {
-+	duk__emit_a_b_c(comp_ctx,
-+	                DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C,
-+	                1 /*true*/,
-+	                regconst,
-+	                0 /*unused*/);
-+}
-+
-+DUK_LOCAL void duk__emit_invalid(duk_compiler_ctx *comp_ctx) {
-+	duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_INVALID, 0);
-+}
-+
-+/*
-+ *  Peephole optimizer for finished bytecode.
-+ *
-+ *  Does not remove opcodes; currently only straightens out unconditional
-+ *  jump chains which are generated by several control structures.
-+ */
-+
-+DUK_LOCAL void duk__peephole_optimize_bytecode(duk_compiler_ctx *comp_ctx) {
-+	duk_hbuffer_dynamic *h;
-+	duk_compiler_instr *bc;
-+	duk_small_uint_t iter;
-+	duk_int_t i, n;
-+	duk_int_t count_opt;
-+
-+	h = comp_ctx->curr_func.h_code;
-+	DUK_ASSERT(h != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h));
-+
-+	bc = (duk_compiler_instr *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, h);
-+#if defined(DUK_USE_BUFLEN16)
-+	/* No need to assert, buffer size maximum is 0xffff. */
-+#else
-+	DUK_ASSERT(DUK_HBUFFER_GET_SIZE(h) / sizeof(duk_compiler_instr) <= DUK_INT_MAX);  /* bytecode limits */
-+#endif
-+	n = (duk_int_t) (DUK_HBUFFER_GET_SIZE(h) / sizeof(duk_compiler_instr));
-+
-+	for (iter = 0; iter < DUK_COMPILER_PEEPHOLE_MAXITER; iter++) {
-+		count_opt = 0;
-+
-+		for (i = 0; i < n; i++) {
-+			duk_instr_t ins;
-+			duk_int_t target_pc1;
-+			duk_int_t target_pc2;
-+
-+			ins = bc[i].ins;
-+			if (DUK_DEC_OP(ins) != DUK_OP_JUMP) {
-+				continue;
-+			}
-+
-+			target_pc1 = i + 1 + DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS;
-+			DUK_DDD(DUK_DDDPRINT("consider jump at pc %ld; target_pc=%ld", (long) i, (long) target_pc1));
-+			DUK_ASSERT(target_pc1 >= 0);
-+			DUK_ASSERT(target_pc1 < n);
-+
-+			/* Note: if target_pc1 == i, we'll optimize a jump to itself.
-+			 * This does not need to be checked for explicitly; the case
-+			 * is rare and max iter breaks us out.
-+			 */
-+
-+			ins = bc[target_pc1].ins;
-+			if (DUK_DEC_OP(ins) != DUK_OP_JUMP) {
-+				continue;
-+			}
-+
-+			target_pc2 = target_pc1 + 1 + DUK_DEC_ABC(ins) - DUK_BC_JUMP_BIAS;
-+
-+			DUK_DDD(DUK_DDDPRINT("optimizing jump at pc %ld; old target is %ld -> new target is %ld",
-+			                     (long) i, (long) target_pc1, (long) target_pc2));
-+
-+			bc[i].ins = DUK_ENC_OP_ABC(DUK_OP_JUMP, target_pc2 - (i + 1) + DUK_BC_JUMP_BIAS);
-+
-+			count_opt++;
-+		}
-+
-+		DUK_DD(DUK_DDPRINT("optimized %ld jumps on peephole round %ld", (long) count_opt, (long) (iter + 1)));
-+
-+		if (count_opt == 0) {
-+			break;
-+		}
-+	}
-+}
-+
-+/*
-+ *  Intermediate value helpers
-+ */
-+
-+#define DUK__ISREG(comp_ctx,x)              (((x) & DUK__CONST_MARKER) == 0)
-+#define DUK__ISCONST(comp_ctx,x)            (((x) & DUK__CONST_MARKER) != 0)
-+#define DUK__ISTEMP(comp_ctx,x)             (DUK__ISREG((comp_ctx), (x)) && (duk_regconst_t) (x) >= (duk_regconst_t) ((comp_ctx)->curr_func.temp_first))
-+#define DUK__GETTEMP(comp_ctx)              ((comp_ctx)->curr_func.temp_next)
-+#define DUK__SETTEMP(comp_ctx,x)            ((comp_ctx)->curr_func.temp_next = (x))  /* dangerous: must only lower (temp_max not updated) */
-+#define DUK__SETTEMP_CHECKMAX(comp_ctx,x)   duk__settemp_checkmax((comp_ctx),(x))
-+#define DUK__ALLOCTEMP(comp_ctx)            duk__alloctemp((comp_ctx))
-+#define DUK__ALLOCTEMPS(comp_ctx,count)     duk__alloctemps((comp_ctx),(count))
-+
-+/* Flags for intermediate value coercions.  A flag for using a forced reg
-+ * is not needed, the forced_reg argument suffices and generates better
-+ * code (it is checked as it is used).
-+ */
-+#define DUK__IVAL_FLAG_ALLOW_CONST          (1 << 0)  /* allow a constant to be returned */
-+#define DUK__IVAL_FLAG_REQUIRE_TEMP         (1 << 1)  /* require a (mutable) temporary as a result */
-+#define DUK__IVAL_FLAG_REQUIRE_SHORT        (1 << 2)  /* require a short (8-bit) reg/const which fits into bytecode B/C slot */
-+
-+/* XXX: some code might benefit from DUK__SETTEMP_IFTEMP(ctx,x) */
-+
-+DUK_LOCAL void duk__copy_ispec(duk_compiler_ctx *comp_ctx, duk_ispec *src, duk_ispec *dst) {
-+	duk_context *ctx = (duk_context *) comp_ctx->thr;
-+
-+	dst->t = src->t;
-+	dst->regconst = src->regconst;
-+	duk_copy(ctx, src->valstack_idx, dst->valstack_idx);
-+}
-+
-+DUK_LOCAL void duk__copy_ivalue(duk_compiler_ctx *comp_ctx, duk_ivalue *src, duk_ivalue *dst) {
-+	duk_context *ctx = (duk_context *) comp_ctx->thr;
-+
-+	dst->t = src->t;
-+	dst->op = src->op;
-+	dst->x1.t = src->x1.t;
-+	dst->x1.regconst = src->x1.regconst;
-+	dst->x2.t = src->x2.t;
-+	dst->x2.regconst = src->x2.regconst;
-+	duk_copy(ctx, src->x1.valstack_idx, dst->x1.valstack_idx);
-+	duk_copy(ctx, src->x2.valstack_idx, dst->x2.valstack_idx);
-+}
-+
-+/* XXX: to util */
-+DUK_LOCAL duk_bool_t duk__is_whole_get_int32(duk_double_t x, duk_int32_t *ival) {
-+	duk_small_int_t c;
-+	duk_int32_t t;
-+
-+	c = DUK_FPCLASSIFY(x);
-+	if (c == DUK_FP_NORMAL || (c == DUK_FP_ZERO && !DUK_SIGNBIT(x))) {
-+		/* Don't allow negative zero as it will cause trouble with
-+		 * LDINT+LDINTX.  But positive zero is OK.
-+		 */
-+		t = (duk_int32_t) x;
-+		if ((duk_double_t) t == x) {
-+			*ival = t;
-+			return 1;
-+		}
-+	}
-+
-+	return 0;
-+}
-+
-+DUK_LOCAL duk_reg_t duk__alloctemps(duk_compiler_ctx *comp_ctx, duk_small_int_t num) {
-+	duk_reg_t res;
-+
-+	res = comp_ctx->curr_func.temp_next;
-+	comp_ctx->curr_func.temp_next += num;
-+
-+	if (comp_ctx->curr_func.temp_next > DUK__MAX_TEMPS) {  /* == DUK__MAX_TEMPS is OK */
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_TEMP_LIMIT);
-+	}
-+
-+	/* maintain highest 'used' temporary, needed to figure out nregs of function */
-+	if (comp_ctx->curr_func.temp_next > comp_ctx->curr_func.temp_max) {
-+		comp_ctx->curr_func.temp_max = comp_ctx->curr_func.temp_next;
-+	}
-+
-+	return res;
-+}
-+
-+DUK_LOCAL duk_reg_t duk__alloctemp(duk_compiler_ctx *comp_ctx) {
-+	return duk__alloctemps(comp_ctx, 1);
-+}
-+
-+DUK_LOCAL void duk__settemp_checkmax(duk_compiler_ctx *comp_ctx, duk_reg_t temp_next) {
-+	comp_ctx->curr_func.temp_next = temp_next;
-+	if (temp_next > comp_ctx->curr_func.temp_max) {
-+		comp_ctx->curr_func.temp_max = temp_next;
-+	}
-+}
-+
-+/* get const for value at valstack top */
-+DUK_LOCAL duk_regconst_t duk__getconst(duk_compiler_ctx *comp_ctx) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_compiler_func *f = &comp_ctx->curr_func;
-+	duk_tval *tv1;
-+	duk_int_t i, n, n_check;
-+
-+	n = (duk_int_t) duk_get_length(ctx, f->consts_idx);
-+
-+	tv1 = duk_get_tval(ctx, -1);
-+	DUK_ASSERT(tv1 != NULL);
-+
-+#if defined(DUK_USE_FASTINT)
-+	/* Explicit check for fastint downgrade. */
-+	DUK_TVAL_CHKFAST_INPLACE(tv1);
-+#endif
-+
-+	/* Sanity workaround for handling functions with a large number of
-+	 * constants at least somewhat reasonably.  Otherwise checking whether
-+	 * we already have the constant would grow very slow (as it is O(N^2)).
-+	 */
-+	n_check = (n > DUK__GETCONST_MAX_CONSTS_CHECK ? DUK__GETCONST_MAX_CONSTS_CHECK : n);
-+	for (i = 0; i < n_check; i++) {
-+		duk_tval *tv2 = DUK_HOBJECT_A_GET_VALUE_PTR(thr->heap, f->h_consts, i);
-+
-+		/* Strict equality is NOT enough, because we cannot use the same
-+		 * constant for e.g. +0 and -0.
-+		 */
-+		if (duk_js_samevalue(tv1, tv2)) {
-+			DUK_DDD(DUK_DDDPRINT("reused existing constant for %!T -> const index %ld",
-+			                     (duk_tval *) tv1, (long) i));
-+			duk_pop(ctx);
-+			return (duk_regconst_t) (i | DUK__CONST_MARKER);
-+		}
-+	}
-+
-+	if (n > DUK__MAX_CONSTS) {
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_CONST_LIMIT);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("allocating new constant for %!T -> const index %ld",
-+	                     (duk_tval *) tv1, (long) n));
-+	(void) duk_put_prop_index(ctx, f->consts_idx, n);  /* invalidates tv1, tv2 */
-+	return (duk_regconst_t) (n | DUK__CONST_MARKER);
-+}
-+
-+/* Get the value represented by an duk_ispec to a register or constant.
-+ * The caller can control the result by indicating whether or not:
-+ *
-+ *   (1) a constant is allowed (sometimes the caller needs the result to
-+ *       be in a register)
-+ *
-+ *   (2) a temporary register is required (usually when caller requires
-+ *       the register to be safely mutable; normally either a bound
-+ *       register or a temporary register are both OK)
-+ *
-+ *   (3) a forced register target needs to be used
-+ *
-+ * Bytecode may be emitted to generate the necessary value.  The return
-+ * value is either a register or a constant.
-+ */
-+
-+DUK_LOCAL
-+duk_regconst_t duk__ispec_toregconst_raw(duk_compiler_ctx *comp_ctx,
-+                                         duk_ispec *x,
-+                                         duk_reg_t forced_reg,
-+                                         duk_small_uint_t flags) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__ispec_toregconst_raw(): x={%ld:%ld:%!T}, "
-+	                     "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld",
-+	                     (long) x->t,
-+	                     (long) x->regconst,
-+	                     (duk_tval *) duk_get_tval(ctx, x->valstack_idx),
-+	                     (long) forced_reg,
-+	                     (unsigned long) flags,
-+	                     (long) ((flags & DUK__IVAL_FLAG_ALLOW_CONST) ? 1 : 0),
-+	                     (long) ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) ? 1 : 0),
-+	                     (long) ((flags & DUK__IVAL_FLAG_REQUIRE_SHORT) ? 1 : 0)));
-+
-+	switch (x->t) {
-+	case DUK_ISPEC_VALUE: {
-+		duk_tval *tv;
-+
-+		tv = duk_get_tval(ctx, x->valstack_idx);
-+		DUK_ASSERT(tv != NULL);
-+
-+		switch (DUK_TVAL_GET_TAG(tv)) {
-+		case DUK_TAG_UNDEFINED: {
-+			/* Note: although there is no 'undefined' literal, undefined
-+			 * values can occur during compilation as a result of e.g.
-+			 * the 'void' operator.
-+			 */
-+			duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-+			duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_LDUNDEF, (duk_regconst_t) dest);
-+			return (duk_regconst_t) dest;
-+		}
-+		case DUK_TAG_NULL: {
-+			duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-+			duk__emit_extraop_bc(comp_ctx, DUK_EXTRAOP_LDNULL, (duk_regconst_t) dest);
-+			return (duk_regconst_t) dest;
-+		}
-+		case DUK_TAG_BOOLEAN: {
-+			duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-+			duk__emit_extraop_bc(comp_ctx,
-+			                     (DUK_TVAL_GET_BOOLEAN(tv) ? DUK_EXTRAOP_LDTRUE : DUK_EXTRAOP_LDFALSE),
-+			                     (duk_regconst_t) dest);
-+			return (duk_regconst_t) dest;
-+		}
-+		case DUK_TAG_POINTER: {
-+			DUK_UNREACHABLE();
-+			break;
-+		}
-+		case DUK_TAG_STRING: {
-+			duk_hstring *h;
-+			duk_reg_t dest;
-+			duk_regconst_t constidx;
-+
-+			h = DUK_TVAL_GET_STRING(tv);
-+			DUK_UNREF(h);
-+			DUK_ASSERT(h != NULL);
-+
-+#if 0  /* XXX: to be implemented? */
-+			/* Use special opcodes to load short strings */
-+			if (DUK_HSTRING_GET_BYTELEN(h) <= 2) {
-+				/* Encode into a single opcode (18 bits can encode 1-2 bytes + length indicator) */
-+			} else if (DUK_HSTRING_GET_BYTELEN(h) <= 6) {
-+				/* Encode into a double constant (53 bits can encode 6*8 = 48 bits + 3-bit length */
-+			}
-+#endif
-+			duk_dup(ctx, x->valstack_idx);
-+			constidx = duk__getconst(comp_ctx);
-+
-+			if (flags & DUK__IVAL_FLAG_ALLOW_CONST) {
-+				return constidx;
-+			}
-+
-+			dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-+			duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx);
-+			return (duk_regconst_t) dest;
-+		}
-+		case DUK_TAG_OBJECT: {
-+			DUK_UNREACHABLE();
-+			break;
-+		}
-+		case DUK_TAG_BUFFER: {
-+			DUK_UNREACHABLE();
-+			break;
-+		}
-+		case DUK_TAG_LIGHTFUNC: {
-+			DUK_UNREACHABLE();
-+			break;
-+		}
-+#if defined(DUK_USE_FASTINT)
-+		case DUK_TAG_FASTINT:
-+#endif
-+		default: {
-+			/* number */
-+			duk_reg_t dest;
-+			duk_regconst_t constidx;
-+			duk_double_t dval;
-+			duk_int32_t ival;
-+
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+			dval = DUK_TVAL_GET_NUMBER(tv);
-+
-+			if (!(flags & DUK__IVAL_FLAG_ALLOW_CONST)) {
-+				/* A number can be loaded either through a constant, using
-+				 * LDINT, or using LDINT+LDINTX.  LDINT is always a size win,
-+				 * LDINT+LDINTX is not if the constant is used multiple times.
-+				 * Currently always prefer LDINT+LDINTX over a double constant.
-+				 */
-+
-+				if (duk__is_whole_get_int32(dval, &ival)) {
-+					dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-+					duk__emit_load_int32(comp_ctx, dest, ival);
-+					return (duk_regconst_t) dest;
-+				}
-+			}
-+
-+			duk_dup(ctx, x->valstack_idx);
-+			constidx = duk__getconst(comp_ctx);
-+
-+			if (flags & DUK__IVAL_FLAG_ALLOW_CONST) {
-+				return constidx;
-+			} else {
-+				dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-+				duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, constidx);
-+				return (duk_regconst_t) dest;
-+			}
-+		}
-+		}  /* end switch */
-+	}
-+	case DUK_ISPEC_REGCONST: {
-+		if ((x->regconst & DUK__CONST_MARKER) && !(flags & DUK__IVAL_FLAG_ALLOW_CONST)) {
-+			duk_reg_t dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-+			duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, (duk_regconst_t) dest, x->regconst);
-+			return (duk_regconst_t) dest;
-+		} else {
-+			if (forced_reg >= 0) {
-+				if (x->regconst != (duk_regconst_t) forced_reg) {
-+					duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, forced_reg, x->regconst);
-+				}
-+				return (duk_regconst_t) forced_reg;
-+			} else {
-+				if ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) && !DUK__ISTEMP(comp_ctx, x->regconst)) {
-+					duk_reg_t dest = DUK__ALLOCTEMP(comp_ctx);
-+					duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, (duk_regconst_t) dest, x->regconst);
-+					return (duk_regconst_t) dest;
-+				} else {
-+					return x->regconst;
-+				}
-+			}
-+		}
-+	}
-+	default: {
-+		break;
-+	}
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR);
-+	return 0;
-+}
-+
-+DUK_LOCAL void duk__ispec_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ispec *x, duk_reg_t forced_reg) {
-+	DUK_ASSERT(forced_reg >= 0);
-+	(void) duk__ispec_toregconst_raw(comp_ctx, x, forced_reg, 0 /*flags*/);
-+}
-+
-+/* Coerce an duk_ivalue to a 'plain' value by generating the necessary
-+ * arithmetic operations, property access, or variable access bytecode.
-+ * The duk_ivalue argument ('x') is converted into a plain value as a
-+ * side effect.
-+ */
-+DUK_LOCAL void duk__ivalue_toplain_raw(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_reg_t forced_reg) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__ivalue_toplain_raw(): x={t=%ld,op=%ld,x1={%ld:%ld:%!T},x2={%ld:%ld:%!T}}, "
-+	                     "forced_reg=%ld",
-+	                     (long) x->t, (long) x->op,
-+	                     (long) x->x1.t, (long) x->x1.regconst,
-+	                     (duk_tval *) duk_get_tval(ctx, x->x1.valstack_idx),
-+	                     (long) x->x2.t, (long) x->x2.regconst,
-+	                     (duk_tval *) duk_get_tval(ctx, x->x2.valstack_idx),
-+	                     (long) forced_reg));
-+
-+	switch (x->t) {
-+	case DUK_IVAL_PLAIN: {
-+		return;
-+	}
-+	/* XXX: support unary arithmetic ivalues (useful?) */
-+	case DUK_IVAL_ARITH:
-+	case DUK_IVAL_ARITH_EXTRAOP: {
-+		duk_regconst_t arg1;
-+		duk_regconst_t arg2;
-+		duk_reg_t dest;
-+		duk_tval *tv1;
-+		duk_tval *tv2;
-+
-+		DUK_DDD(DUK_DDDPRINT("arith to plain conversion"));
-+
-+		/* inline arithmetic check for constant values */
-+		/* XXX: use the exactly same arithmetic function here as in executor */
-+		if (x->x1.t == DUK_ISPEC_VALUE && x->x2.t == DUK_ISPEC_VALUE && x->t == DUK_IVAL_ARITH) {
-+			tv1 = duk_get_tval(ctx, x->x1.valstack_idx);
-+			tv2 = duk_get_tval(ctx, x->x2.valstack_idx);
-+			DUK_ASSERT(tv1 != NULL);
-+			DUK_ASSERT(tv2 != NULL);
-+
-+			DUK_DDD(DUK_DDDPRINT("arith: tv1=%!T, tv2=%!T",
-+			                     (duk_tval *) tv1,
-+			                     (duk_tval *) tv2));
-+
-+			if (DUK_TVAL_IS_NUMBER(tv1) && DUK_TVAL_IS_NUMBER(tv2)) {
-+				duk_double_t d1 = DUK_TVAL_GET_NUMBER(tv1);
-+				duk_double_t d2 = DUK_TVAL_GET_NUMBER(tv2);
-+				duk_double_t d3;
-+				duk_bool_t accept = 1;
-+
-+				DUK_DDD(DUK_DDDPRINT("arith inline check: d1=%lf, d2=%lf, op=%ld",
-+				                     (double) d1, (double) d2, (long) x->op));
-+				switch (x->op) {
-+				case DUK_OP_ADD:  d3 = d1 + d2; break;
-+				case DUK_OP_SUB:  d3 = d1 - d2; break;
-+				case DUK_OP_MUL:  d3 = d1 * d2; break;
-+				case DUK_OP_DIV:  d3 = d1 / d2; break;
-+				default:          accept = 0; break;
-+				}
-+
-+				if (accept) {
-+					duk_double_union du;
-+					du.d = d3;
-+					DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
-+					d3 = du.d;
-+
-+					x->t = DUK_IVAL_PLAIN;
-+					DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE);
-+					DUK_TVAL_SET_NUMBER(tv1, d3);  /* old value is number: no refcount */
-+					return;
-+				}
-+			} else if (x->op == DUK_OP_ADD && DUK_TVAL_IS_STRING(tv1) && DUK_TVAL_IS_STRING(tv2)) {
-+				/* inline string concatenation */
-+				duk_dup(ctx, x->x1.valstack_idx);
-+				duk_dup(ctx, x->x2.valstack_idx);
-+				duk_concat(ctx, 2);
-+				duk_replace(ctx, x->x1.valstack_idx);
-+				x->t = DUK_IVAL_PLAIN;
-+				DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE);
-+				return;
-+			}
-+		}
-+
-+		arg1 = duk__ispec_toregconst_raw(comp_ctx, &x->x1, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/);
-+		arg2 = duk__ispec_toregconst_raw(comp_ctx, &x->x2, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/);
-+
-+		/* If forced reg, use it as destination.  Otherwise try to
-+		 * use either coerced ispec if it is a temporary.
-+		 *
-+		 * When using extraops, avoid reusing arg2 as dest because that
-+		 * would lead to an LDREG shuffle below.  We still can't guarantee
-+		 * dest != arg2 because we may have a forced_reg.
-+		 */
-+		if (forced_reg >= 0) {
-+			dest = forced_reg;
-+		} else if (DUK__ISTEMP(comp_ctx, arg1)) {
-+			dest = (duk_reg_t) arg1;
-+		} else if (DUK__ISTEMP(comp_ctx, arg2) && x->t != DUK_IVAL_ARITH_EXTRAOP) {
-+			dest = (duk_reg_t) arg2;
-+		} else {
-+			dest = DUK__ALLOCTEMP(comp_ctx);
-+		}
-+
-+		/* Extraop arithmetic opcodes must have destination same as
-+		 * first source.  If second source matches destination we need
-+		 * a temporary register to avoid clobbering the second source.
-+		 *
-+		 * XXX: change calling code to avoid this situation in most cases.
-+		 */
-+
-+		if (x->t == DUK_IVAL_ARITH_EXTRAOP) {
-+			if (!(DUK__ISREG(comp_ctx, arg1) && (duk_reg_t) arg1 == dest)) {
-+				if (DUK__ISREG(comp_ctx, arg2) && (duk_reg_t) arg2 == dest) {
-+					/* arg2 would be clobbered so reassign it to a temp. */
-+					duk_reg_t tempreg;
-+					tempreg = DUK__ALLOCTEMP(comp_ctx);
-+					duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, tempreg, arg2);
-+					arg2 = tempreg;
-+				}
-+
-+				if (DUK__ISREG(comp_ctx, arg1)) {
-+					duk__emit_a_bc(comp_ctx, DUK_OP_LDREG, dest, arg1);
-+				} else {
-+					DUK_ASSERT(DUK__ISCONST(comp_ctx, arg1));
-+					duk__emit_a_bc(comp_ctx, DUK_OP_LDCONST, dest, arg1);
-+				}
-+			}
-+
-+			/* Note: special DUK__EMIT_FLAG_B_IS_TARGETSOURCE
-+			 * used to indicate that B is both a source and a
-+			 * target register.  When shuffled, it needs to be
-+			 * both input and output shuffled.
-+			 */
-+			DUK_ASSERT(DUK__ISREG(comp_ctx, dest));
-+			duk__emit_extraop_b_c(comp_ctx,
-+			                      x->op | DUK__EMIT_FLAG_B_IS_TARGET |
-+			                              DUK__EMIT_FLAG_B_IS_TARGETSOURCE,
-+			                      (duk_regconst_t) dest,
-+			                      (duk_regconst_t) arg2);
-+
-+		} else {
-+			DUK_ASSERT(DUK__ISREG(comp_ctx, dest));
-+			duk__emit_a_b_c(comp_ctx, x->op, (duk_regconst_t) dest, arg1, arg2);
-+		}
-+
-+		x->t = DUK_IVAL_PLAIN;
-+		x->x1.t = DUK_ISPEC_REGCONST;
-+		x->x1.regconst = (duk_regconst_t) dest;
-+		return;
-+	}
-+	case DUK_IVAL_PROP: {
-+		/* XXX: very similar to DUK_IVAL_ARITH - merge? */
-+		duk_regconst_t arg1;
-+		duk_regconst_t arg2;
-+		duk_reg_t dest;
-+
-+		/* Need a short reg/const, does not have to be a mutable temp. */
-+		arg1 = duk__ispec_toregconst_raw(comp_ctx, &x->x1, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/);
-+		arg2 = duk__ispec_toregconst_raw(comp_ctx, &x->x2, -1, DUK__IVAL_FLAG_ALLOW_CONST | DUK__IVAL_FLAG_REQUIRE_SHORT /*flags*/);
-+
-+		/* Pick a destination register.  If either base value or key
-+		 * happens to be a temp value, reuse it as the destination.
-+		 *
-+		 * XXX: The temp must be a "mutable" one, i.e. such that no
-+		 * other expression is using it anymore.  Here this should be
-+		 * the case because the value of a property access expression
-+		 * is neither the base nor the key, but the lookup result.
-+		 */
-+
-+		if (forced_reg >= 0) {
-+			dest = forced_reg;
-+		} else if (DUK__ISTEMP(comp_ctx, arg1)) {
-+			dest = (duk_reg_t) arg1;
-+		} else if (DUK__ISTEMP(comp_ctx, arg2)) {
-+			dest = (duk_reg_t) arg2;
-+		} else {
-+			dest = DUK__ALLOCTEMP(comp_ctx);
-+		}
-+
-+		duk__emit_a_b_c(comp_ctx, DUK_OP_GETPROP, (duk_regconst_t) dest, arg1, arg2);
-+
-+		x->t = DUK_IVAL_PLAIN;
-+		x->x1.t = DUK_ISPEC_REGCONST;
-+		x->x1.regconst = (duk_regconst_t) dest;
-+		return;
-+	}
-+	case DUK_IVAL_VAR: {
-+		/* x1 must be a string */
-+		duk_reg_t dest;
-+		duk_reg_t reg_varbind;
-+		duk_regconst_t rc_varname;
-+
-+		DUK_ASSERT(x->x1.t == DUK_ISPEC_VALUE);
-+
-+		duk_dup(ctx, x->x1.valstack_idx);
-+		if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
-+			x->t = DUK_IVAL_PLAIN;
-+			x->x1.t = DUK_ISPEC_REGCONST;
-+			x->x1.regconst = (duk_regconst_t) reg_varbind;
-+		} else {
-+			dest = (forced_reg >= 0 ? forced_reg : DUK__ALLOCTEMP(comp_ctx));
-+			duk__emit_a_bc(comp_ctx, DUK_OP_GETVAR, (duk_regconst_t) dest, rc_varname);
-+			x->t = DUK_IVAL_PLAIN;
-+			x->x1.t = DUK_ISPEC_REGCONST;
-+			x->x1.regconst = (duk_regconst_t) dest;
-+		}
-+		return;
-+	}
-+	case DUK_IVAL_NONE:
-+	default: {
-+		break;
-+	}
-+	}
-+
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR);
-+	return;
-+}
-+
-+/* evaluate to plain value, no forced register (temp/bound reg both ok) */
-+DUK_LOCAL void duk__ivalue_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *x) {
-+	duk__ivalue_toplain_raw(comp_ctx, x, -1 /*forced_reg*/);
-+}
-+
-+/* evaluate to final form (e.g. coerce GETPROP to code), throw away temp */
-+DUK_LOCAL void duk__ivalue_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *x) {
-+	duk_reg_t temp;
-+
-+	/* If duk__ivalue_toplain_raw() allocates a temp, forget it and
-+	 * restore next temp state.
-+	 */
-+	temp = DUK__GETTEMP(comp_ctx);
-+	duk__ivalue_toplain_raw(comp_ctx, x, -1 /*forced_reg*/);
-+	DUK__SETTEMP(comp_ctx, temp);
-+}
-+
-+/* Coerce an duk_ivalue to a register or constant; result register may
-+ * be a temp or a bound register.
-+ *
-+ * The duk_ivalue argument ('x') is converted into a regconst as a
-+ * side effect.
-+ */
-+DUK_LOCAL
-+duk_regconst_t duk__ivalue_toregconst_raw(duk_compiler_ctx *comp_ctx,
-+                                          duk_ivalue *x,
-+                                          duk_reg_t forced_reg,
-+                                          duk_small_uint_t flags) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_regconst_t reg;
-+	DUK_UNREF(thr);
-+	DUK_UNREF(ctx);
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__ivalue_toregconst_raw(): x={t=%ld,op=%ld,x1={%ld:%ld:%!T},x2={%ld:%ld:%!T}}, "
-+	                     "forced_reg=%ld, flags 0x%08lx: allow_const=%ld require_temp=%ld require_short=%ld",
-+	                     (long) x->t, (long) x->op,
-+	                     (long) x->x1.t, (long) x->x1.regconst,
-+	                     (duk_tval *) duk_get_tval(ctx, x->x1.valstack_idx),
-+	                     (long) x->x2.t, (long) x->x2.regconst,
-+	                     (duk_tval *) duk_get_tval(ctx, x->x2.valstack_idx),
-+	                     (long) forced_reg,
-+	                     (unsigned long) flags,
-+	                     (long) ((flags & DUK__IVAL_FLAG_ALLOW_CONST) ? 1 : 0),
-+	                     (long) ((flags & DUK__IVAL_FLAG_REQUIRE_TEMP) ? 1 : 0),
-+	                     (long) ((flags & DUK__IVAL_FLAG_REQUIRE_SHORT) ? 1 : 0)));
-+
-+	/* first coerce to a plain value */
-+	duk__ivalue_toplain_raw(comp_ctx, x, forced_reg);
-+	DUK_ASSERT(x->t == DUK_IVAL_PLAIN);
-+
-+	/* then to a register */
-+	reg = duk__ispec_toregconst_raw(comp_ctx, &x->x1, forced_reg, flags);
-+	x->x1.t = DUK_ISPEC_REGCONST;
-+	x->x1.regconst = reg;
-+
-+	return reg;
-+}
-+
-+DUK_LOCAL duk_reg_t duk__ivalue_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x) {
-+	return duk__ivalue_toregconst_raw(comp_ctx, x, -1, 0 /*flags*/);
-+}
-+
-+#if 0  /* unused */
-+DUK_LOCAL duk_reg_t duk__ivalue_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x) {
-+	return duk__ivalue_toregconst_raw(comp_ctx, x, -1, DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/);
-+}
-+#endif
-+
-+DUK_LOCAL void duk__ivalue_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *x, duk_int_t forced_reg) {
-+	DUK_ASSERT(forced_reg >= 0);
-+	(void) duk__ivalue_toregconst_raw(comp_ctx, x, forced_reg, 0 /*flags*/);
-+}
-+
-+DUK_LOCAL duk_regconst_t duk__ivalue_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *x) {
-+	return duk__ivalue_toregconst_raw(comp_ctx, x, -1, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
-+}
-+
-+/* The issues below can be solved with better flags */
-+
-+/* XXX: many operations actually want toforcedtemp() -- brand new temp? */
-+/* XXX: need a toplain_ignore() which will only coerce a value to a temp
-+ * register if it might have a side effect.  Side-effect free values do not
-+ * need to be coerced.
-+ */
-+
-+/*
-+ *  Identifier handling
-+ */
-+
-+DUK_LOCAL duk_reg_t duk__lookup_active_register_binding(duk_compiler_ctx *comp_ctx) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *h_varname;
-+	duk_reg_t ret;
-+
-+	DUK_DDD(DUK_DDDPRINT("resolving identifier reference to '%!T'",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/*
-+	 *  Special name handling
-+	 */
-+
-+	h_varname = duk_get_hstring(ctx, -1);
-+	DUK_ASSERT(h_varname != NULL);
-+
-+	if (h_varname == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)) {
-+		DUK_DDD(DUK_DDDPRINT("flagging function as accessing 'arguments'"));
-+		comp_ctx->curr_func.id_access_arguments = 1;
-+	}
-+
-+	/*
-+	 *  Inside one or more 'with' statements fall back to slow path always.
-+	 *  (See e.g. test-stmt-with.js.)
-+	 */
-+
-+	if (comp_ctx->curr_func.with_depth > 0) {
-+		DUK_DDD(DUK_DDDPRINT("identifier lookup inside a 'with' -> fall back to slow path"));
-+		goto slow_path;
-+	}
-+
-+	/*
-+	 *  Any catch bindings ("catch (e)") also affect identifier binding.
-+	 *
-+	 *  Currently, the varmap is modified for the duration of the catch
-+	 *  clause to ensure any identifier accesses with the catch variable
-+	 *  name will use slow path.
-+	 */
-+
-+	duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);
-+	if (duk_is_number(ctx, -1)) {
-+		ret = duk_to_int(ctx, -1);
-+		duk_pop(ctx);
-+	} else {
-+		duk_pop(ctx);
-+		goto slow_path;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("identifier lookup -> reg %ld", (long) ret));
-+	return ret;
-+
-+ slow_path:
-+	DUK_DDD(DUK_DDDPRINT("identifier lookup -> slow path"));
-+
-+	comp_ctx->curr_func.id_access_slow = 1;
-+	return (duk_reg_t) -1;
-+}
-+
-+/* Lookup an identifier name in the current varmap, indicating whether the
-+ * identifier is register-bound and if not, allocating a constant for the
-+ * identifier name.  Returns 1 if register-bound, 0 otherwise.  Caller can
-+ * also check (out_reg_varbind >= 0) to check whether or not identifier is
-+ * register bound.  The caller must NOT use out_rc_varname at all unless
-+ * return code is 0 or out_reg_varbind is < 0; this is becuase out_rc_varname
-+ * is unsigned and doesn't have a "unused" / none value.
-+ */
-+DUK_LOCAL duk_bool_t duk__lookup_lhs(duk_compiler_ctx *comp_ctx, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_reg_t reg_varbind;
-+	duk_regconst_t rc_varname;
-+
-+	/* [ ... varname ] */
-+
-+	duk_dup_top(ctx);
-+	reg_varbind = duk__lookup_active_register_binding(comp_ctx);
-+
-+	if (reg_varbind >= 0) {
-+		*out_reg_varbind = reg_varbind;
-+		*out_rc_varname = 0;  /* duk_regconst_t is unsigned, so use 0 as dummy value (ignored by caller) */
-+		duk_pop(ctx);
-+		return 1;
-+	} else {
-+		rc_varname = duk__getconst(comp_ctx);
-+		*out_reg_varbind = -1;
-+		*out_rc_varname = rc_varname;
-+		return 0;
-+	}
-+}
-+
-+/*
-+ *  Label handling
-+ *
-+ *  Labels are initially added with flags prohibiting both break and continue.
-+ *  When the statement type is finally uncovered (after potentially multiple
-+ *  labels), all the labels are updated to allow/prohibit break and continue.
-+ */
-+
-+DUK_LOCAL void duk__add_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_int_t pc_label, duk_int_t label_id) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_size_t n;
-+	duk_size_t new_size;
-+	duk_uint8_t *p;
-+	duk_labelinfo *li_start, *li;
-+
-+	/* Duplicate (shadowing) labels are not allowed, except for the empty
-+	 * labels (which are used as default labels for switch and iteration
-+	 * statements).
-+	 *
-+	 * We could also allow shadowing of non-empty pending labels without any
-+	 * other issues than breaking the required label shadowing requirements
-+	 * of the E5 specification, see Section 12.12.
-+	 */
-+
-+	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
-+	li_start = (duk_labelinfo *) p;
-+	li = (duk_labelinfo *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
-+	n = (duk_size_t) (li - li_start);
-+
-+	while (li > li_start) {
-+		li--;
-+
-+		if (li->h_label == h_label && h_label != DUK_HTHREAD_STRING_EMPTY_STRING(thr)) {
-+			DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_DUPLICATE_LABEL);
-+		}
-+	}
-+
-+	duk_push_hstring(ctx, h_label);
-+	DUK_ASSERT(n <= DUK_UARRIDX_MAX);  /* label limits */
-+	(void) duk_put_prop_index(ctx, comp_ctx->curr_func.labelnames_idx, (duk_uarridx_t) n);
-+
-+	new_size = (n + 1) * sizeof(duk_labelinfo);
-+	duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size, new_size);
-+	/* XXX: spare handling, slow now */
-+
-+	/* relookup after possible realloc */
-+	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
-+	li_start = (duk_labelinfo *) p;
-+	DUK_UNREF(li_start);  /* silence scan-build warning */
-+	li = (duk_labelinfo *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
-+	li--;
-+
-+	/* Labels can be used for iteration statements but also for other statements,
-+	 * in particular a label can be used for a block statement.  All cases of a
-+	 * named label accept a 'break' so that flag is set here.  Iteration statements
-+	 * also allow 'continue', so that flag is updated when we figure out the
-+	 * statement type.
-+	 */
-+
-+	li->flags = DUK_LABEL_FLAG_ALLOW_BREAK;
-+	li->label_id = label_id;
-+	li->h_label = h_label;
-+	li->catch_depth = comp_ctx->curr_func.catch_depth;   /* catch depth from current func */
-+	li->pc_label = pc_label;
-+
-+	DUK_DDD(DUK_DDDPRINT("registered label: flags=0x%08lx, id=%ld, name=%!O, catch_depth=%ld, pc_label=%ld",
-+	                     (unsigned long) li->flags, (long) li->label_id, (duk_heaphdr *) li->h_label,
-+	                     (long) li->catch_depth, (long) li->pc_label));
-+}
-+
-+/* Update all labels with matching label_id. */
-+DUK_LOCAL void duk__update_label_flags(duk_compiler_ctx *comp_ctx, duk_int_t label_id, duk_small_uint_t flags) {
-+	duk_uint8_t *p;
-+	duk_labelinfo *li_start, *li;
-+
-+	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(comp_ctx->thr->heap, comp_ctx->curr_func.h_labelinfos);
-+	li_start = (duk_labelinfo *) p;
-+	li = (duk_labelinfo *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
-+
-+	/* Match labels starting from latest; once label_id no longer matches, we can
-+	 * safely exit without checking the rest of the labels (only the topmost labels
-+	 * are ever updated).
-+	 */
-+	while (li > li_start) {
-+		li--;
-+
-+		if (li->label_id != label_id) {
-+			break;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("updating (overwriting) label flags for li=%p, label_id=%ld, flags=%ld",
-+		                     (void *) li, (long) label_id, (long) flags));
-+
-+		li->flags = flags;
-+	}
-+}
-+
-+/* Lookup active label information.  Break/continue distinction is necessary to handle switch
-+ * statement related labels correctly: a switch will only catch a 'break', not a 'continue'.
-+ *
-+ * An explicit label cannot appear multiple times in the active set, but empty labels (unlabelled
-+ * iteration and switch statements) can.  A break will match the closest unlabelled or labelled
-+ * statement.  A continue will match the closest unlabelled or labelled iteration statement.  It is
-+ * a syntax error if a continue matches a labelled switch statement; because an explicit label cannot
-+ * be duplicated, the continue cannot match any valid label outside the switch.
-+ *
-+ * A side effect of these rules is that a LABEL statement related to a switch should never actually
-+ * catch a continue abrupt completion at run-time.  Hence an INVALID opcode can be placed in the
-+ * continue slot of the switch's LABEL statement.
-+ */
-+
-+/* XXX: awkward, especially the bunch of separate output values -> output struct? */
-+DUK_LOCAL void duk__lookup_active_label(duk_compiler_ctx *comp_ctx, duk_hstring *h_label, duk_bool_t is_break, duk_int_t *out_label_id, duk_int_t *out_label_catch_depth, duk_int_t *out_label_pc, duk_bool_t *out_is_closest) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_uint8_t *p;
-+	duk_labelinfo *li_start, *li_end, *li;
-+	duk_bool_t match = 0;
-+
-+	DUK_DDD(DUK_DDDPRINT("looking up active label: label='%!O', is_break=%ld",
-+	                     (duk_heaphdr *) h_label, (long) is_break));
-+
-+	DUK_UNREF(ctx);
-+
-+	p = (duk_uint8_t *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(thr->heap, comp_ctx->curr_func.h_labelinfos);
-+	li_start = (duk_labelinfo *) p;
-+	li_end = (duk_labelinfo *) (p + DUK_HBUFFER_GET_SIZE(comp_ctx->curr_func.h_labelinfos));
-+	li = li_end;
-+
-+	/* Match labels starting from latest label because there can be duplicate empty
-+	 * labels in the label set.
-+	 */
-+	while (li > li_start) {
-+		li--;
-+
-+		if (li->h_label != h_label) {
-+			DUK_DDD(DUK_DDDPRINT("labelinfo[%ld] ->'%!O' != %!O",
-+			                     (long) (li - li_start),
-+			                     (duk_heaphdr *) li->h_label,
-+			                     (duk_heaphdr *) h_label));
-+			continue;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("labelinfo[%ld] -> '%!O' label name matches (still need to check type)",
-+		                     (long) (li - li_start), (duk_heaphdr *) h_label));
-+
-+		/* currently all labels accept a break, so no explicit check for it now */
-+		DUK_ASSERT(li->flags & DUK_LABEL_FLAG_ALLOW_BREAK);
-+
-+		if (is_break) {
-+			/* break matches always */
-+			match = 1;
-+			break;
-+		} else if (li->flags & DUK_LABEL_FLAG_ALLOW_CONTINUE) {
-+			/* iteration statements allow continue */
-+			match = 1;
-+			break;
-+		} else {
-+			/* continue matched this label -- we can only continue if this is the empty
-+			 * label, for which duplication is allowed, and thus there is hope of
-+			 * finding a match deeper in the label stack.
-+			 */
-+			if (h_label != DUK_HTHREAD_STRING_EMPTY_STRING(thr)) {
-+				DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_LABEL);
-+			} else {
-+				DUK_DDD(DUK_DDDPRINT("continue matched an empty label which does not "
-+				                     "allow a continue -> continue lookup deeper in label stack"));
-+			}
-+		}
-+	}
-+	/* XXX: match flag is awkward, rework */
-+	if (!match) {
-+		DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_LABEL);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("label match: %!O -> label_id %ld, catch_depth=%ld, pc_label=%ld",
-+	                     (duk_heaphdr *) h_label, (long) li->label_id,
-+	                     (long) li->catch_depth, (long) li->pc_label));
-+
-+	*out_label_id = li->label_id;
-+	*out_label_catch_depth = li->catch_depth;
-+	*out_label_pc = li->pc_label;
-+	*out_is_closest = (li == li_end - 1);
-+}
-+
-+DUK_LOCAL void duk__reset_labels_to_length(duk_compiler_ctx *comp_ctx, duk_int_t len) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_size_t new_size;
-+
-+	/* XXX: duk_set_length */
-+	new_size = sizeof(duk_labelinfo) * (duk_size_t) len;
-+	duk_push_int(ctx, len);
-+	duk_put_prop_stridx(ctx, comp_ctx->curr_func.labelnames_idx, DUK_STRIDX_LENGTH);
-+	duk_hbuffer_resize(thr, comp_ctx->curr_func.h_labelinfos, new_size, new_size);  /* XXX: spare handling */
-+}
-+
-+/*
-+ *  Expression parsing: duk__expr_nud(), duk__expr_led(), duk__expr_lbp(), and helpers.
-+ *
-+ *  - duk__expr_nud(): ("null denotation"): process prev_token as a "start" of an expression (e.g. literal)
-+ *  - duk__expr_led(): ("left denotation"): process prev_token in the "middle" of an expression (e.g. operator)
-+ *  - duk__expr_lbp(): ("left-binding power"): return left-binding power of curr_token
-+ */
-+
-+/* object literal key tracking flags */
-+#define DUK__OBJ_LIT_KEY_PLAIN  (1 << 0)  /* key encountered as a plain property */
-+#define DUK__OBJ_LIT_KEY_GET    (1 << 1)  /* key encountered as a getter */
-+#define DUK__OBJ_LIT_KEY_SET    (1 << 2)  /* key encountered as a setter */
-+
-+DUK_LOCAL void duk__nud_array_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_reg_t reg_obj;                 /* result reg */
-+	duk_reg_t reg_temp;                /* temp reg */
-+	duk_reg_t temp_start;              /* temp reg value for start of loop */
-+	duk_small_uint_t max_init_values;  /* max # of values initialized in one MPUTARR set */
-+	duk_small_uint_t num_values;       /* number of values in current MPUTARR set */
-+	duk_uarridx_t curr_idx;            /* current (next) array index */
-+	duk_uarridx_t start_idx;           /* start array index of current MPUTARR set */
-+	duk_uarridx_t init_idx;            /* last array index explicitly initialized, +1 */
-+	duk_bool_t require_comma;          /* next loop requires a comma */
-+
-+	/* DUK_TOK_LBRACKET already eaten, current token is right after that */
-+	DUK_ASSERT(comp_ctx->prev_token.t == DUK_TOK_LBRACKET);
-+
-+	max_init_values = DUK__MAX_ARRAY_INIT_VALUES;  /* XXX: depend on available temps? */
-+
-+	reg_obj = DUK__ALLOCTEMP(comp_ctx);
-+	duk__emit_extraop_b_c(comp_ctx,
-+	                      DUK_EXTRAOP_NEWARR | DUK__EMIT_FLAG_B_IS_TARGET,
-+	                      reg_obj,
-+	                      0);  /* XXX: patch initial size afterwards? */
-+	temp_start = DUK__GETTEMP(comp_ctx);
-+
-+	/*
-+	 *  Emit initializers in sets of maximum max_init_values.
-+	 *  Corner cases such as single value initializers do not have
-+	 *  special handling now.
-+	 *
-+	 *  Elided elements must not be emitted as 'undefined' values,
-+	 *  because such values would be enumerable (which is incorrect).
-+	 *  Also note that trailing elisions must be reflected in the
-+	 *  length of the final array but cause no elements to be actually
-+	 *  inserted.
-+	 */
-+
-+	curr_idx = 0;
-+	init_idx = 0;         /* tracks maximum initialized index + 1 */
-+	start_idx = 0;
-+	require_comma = 0;
-+
-+	for (;;) {
-+		num_values = 0;
-+		DUK__SETTEMP(comp_ctx, temp_start);
-+
-+		if (comp_ctx->curr_token.t == DUK_TOK_RBRACKET) {
-+			break;
-+		}
-+
-+		for (;;) {
-+			if (comp_ctx->curr_token.t == DUK_TOK_RBRACKET) {
-+				/* the outer loop will recheck and exit */
-+				break;
-+			}
-+
-+			/* comma check */
-+			if (require_comma) {
-+				if (comp_ctx->curr_token.t == DUK_TOK_COMMA) {
-+					/* comma after a value, expected */
-+					duk__advance(comp_ctx);
-+					require_comma = 0;
-+					continue;
-+				} else {
-+					goto syntax_error;
-+				}
-+			} else {
-+				if (comp_ctx->curr_token.t == DUK_TOK_COMMA) {
-+					/* elision - flush */
-+					curr_idx++;
-+					duk__advance(comp_ctx);
-+					/* if num_values > 0, MPUTARR emitted by outer loop after break */
-+					break;
-+				}
-+			}
-+			/* else an array initializer element */
-+
-+			/* initial index */
-+			if (num_values == 0) {
-+				start_idx = curr_idx;
-+				reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+				duk__emit_load_int32(comp_ctx, reg_temp, (duk_int32_t) start_idx);
-+			}
-+
-+			reg_temp = DUK__ALLOCTEMP(comp_ctx);   /* alloc temp just in case, to update max temp */
-+			DUK__SETTEMP(comp_ctx, reg_temp);
-+			duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);
-+			DUK__SETTEMP(comp_ctx, reg_temp + 1);
-+
-+			num_values++;
-+			curr_idx++;
-+			require_comma = 1;
-+
-+			if (num_values >= max_init_values) {
-+				/* MPUTARR emitted by outer loop */
-+				break;
-+			}
-+		}
-+
-+		if (num_values > 0) {
-+			/* - A is a source register (it's not a write target, but used
-+			 *   to identify the target object) but can be shuffled.
-+			 * - B cannot be shuffled normally because it identifies a range
-+			 *   of registers, the emitter has special handling for this
-+			 *   (the "no shuffle" flag must not be set).
-+			 * - C is a non-register number and cannot be shuffled, but
-+			 *   never needs to be.
-+			 */
-+			duk__emit_a_b_c(comp_ctx,
-+			                DUK_OP_MPUTARR |
-+			                    DUK__EMIT_FLAG_NO_SHUFFLE_C |
-+			                    DUK__EMIT_FLAG_A_IS_SOURCE,
-+			                (duk_regconst_t) reg_obj,
-+			                (duk_regconst_t) temp_start,
-+			                (duk_regconst_t) num_values);
-+			init_idx = start_idx + num_values;
-+
-+			/* num_values and temp_start reset at top of outer loop */
-+		}
-+	}
-+
-+	DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RBRACKET);
-+	duk__advance(comp_ctx);
-+
-+	DUK_DDD(DUK_DDDPRINT("array literal done, curridx=%ld, initidx=%ld",
-+	                     (long) curr_idx, (long) init_idx));
-+
-+	/* trailing elisions? */
-+	if (curr_idx > init_idx) {
-+		/* yes, must set array length explicitly */
-+		DUK_DDD(DUK_DDDPRINT("array literal has trailing elisions which affect its length"));
-+		reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+		duk__emit_load_int32(comp_ctx, reg_temp, (duk_int_t) curr_idx);
-+		duk__emit_extraop_b_c(comp_ctx,
-+		                      DUK_EXTRAOP_SETALEN,
-+		                      (duk_regconst_t) reg_obj,
-+		                      (duk_regconst_t) reg_temp);
-+	}
-+
-+	DUK__SETTEMP(comp_ctx, temp_start);
-+
-+	res->t = DUK_IVAL_PLAIN;
-+	res->x1.t = DUK_ISPEC_REGCONST;
-+	res->x1.regconst = (duk_regconst_t) reg_obj;
-+	return;
-+
-+ syntax_error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_ARRAY_LITERAL);
-+}
-+
-+/* duplicate/invalid key checks; returns 1 if syntax error */
-+DUK_LOCAL duk_bool_t duk__nud_object_literal_key_check(duk_compiler_ctx *comp_ctx, duk_small_uint_t new_key_flags) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_small_uint_t key_flags;
-+
-+	/* [ ... key_obj key ] */
-+
-+	DUK_ASSERT(duk_is_string(ctx, -1));
-+
-+	/*
-+	 *  'key_obj' tracks keys encountered so far by associating an
-+	 *  integer with flags with already encountered keys.  The checks
-+	 *  below implement E5 Section 11.1.5, step 4 for production:
-+	 *
-+	 *    PropertyNameAndValueList: PropertyNameAndValueList , PropertyAssignment
-+	 */
-+
-+	duk_dup(ctx, -1);       /* [ ... key_obj key key ] */
-+	duk_get_prop(ctx, -3);  /* [ ... key_obj key val ] */
-+	key_flags = duk_to_int(ctx, -1);
-+	duk_pop(ctx);           /* [ ... key_obj key ] */
-+
-+	if (new_key_flags & DUK__OBJ_LIT_KEY_PLAIN) {
-+		if ((key_flags & DUK__OBJ_LIT_KEY_PLAIN) && comp_ctx->curr_func.is_strict) {
-+			/* step 4.a */
-+			DUK_DDD(DUK_DDDPRINT("duplicate key: plain key appears twice in strict mode"));
-+			return 1;
-+		}
-+		if (key_flags & (DUK__OBJ_LIT_KEY_GET | DUK__OBJ_LIT_KEY_SET)) {
-+			/* step 4.c */
-+			DUK_DDD(DUK_DDDPRINT("duplicate key: plain key encountered after setter/getter"));
-+			return 1;
-+		}
-+	} else {
-+		if (key_flags & DUK__OBJ_LIT_KEY_PLAIN) {
-+			/* step 4.b */
-+			DUK_DDD(DUK_DDDPRINT("duplicate key: getter/setter encountered after plain key"));
-+			return 1;
-+		}
-+		if (key_flags & new_key_flags) {
-+			/* step 4.d */
-+			DUK_DDD(DUK_DDDPRINT("duplicate key: getter/setter encountered twice"));
-+			return 1;
-+		}
-+	}
-+
-+	new_key_flags |= key_flags;
-+	DUK_DDD(DUK_DDDPRINT("setting/updating key %!T flags: 0x%08lx -> 0x%08lx",
-+	                     (duk_tval *) duk_get_tval(ctx, -1),
-+	                     (unsigned long) key_flags,
-+	                     (unsigned long) new_key_flags));
-+	duk_dup(ctx, -1);
-+	duk_push_int(ctx, new_key_flags);   /* [ ... key_obj key key flags ] */
-+	duk_put_prop(ctx, -4);              /* [ ... key_obj key ] */
-+
-+	return 0;
-+}
-+
-+DUK_LOCAL void duk__nud_object_literal(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_reg_t reg_obj;                /* result reg */
-+	duk_reg_t reg_key;                /* temp reg for key literal */
-+	duk_reg_t reg_temp;               /* temp reg */
-+	duk_reg_t temp_start;             /* temp reg value for start of loop */
-+	duk_small_uint_t max_init_pairs;  /* max # of key-value pairs initialized in one MPUTOBJ set */
-+	duk_small_uint_t num_pairs;       /* number of pairs in current MPUTOBJ set */
-+	duk_bool_t first;                 /* first value: comma must not precede the value */
-+	duk_bool_t is_set, is_get;        /* temps */
-+
-+	DUK_ASSERT(comp_ctx->prev_token.t == DUK_TOK_LCURLY);
-+
-+	max_init_pairs = DUK__MAX_OBJECT_INIT_PAIRS;  /* XXX: depend on available temps? */
-+
-+	reg_obj = DUK__ALLOCTEMP(comp_ctx);
-+	duk__emit_extraop_b_c(comp_ctx,
-+	                      DUK_EXTRAOP_NEWOBJ | DUK__EMIT_FLAG_B_IS_TARGET,
-+	                      reg_obj,
-+	                      0);  /* XXX: patch initial size afterwards? */
-+	temp_start = DUK__GETTEMP(comp_ctx);
-+
-+	/* temp object for tracking / detecting duplicate keys */
-+	duk_push_object(ctx);
-+
-+	/*
-+	 *  Emit initializers in sets of maximum max_init_pairs keys.
-+	 *  Setter/getter is handled separately and terminates the
-+	 *  current set of initializer values.  Corner cases such as
-+	 *  single value initializers do not have special handling now.
-+	 */
-+
-+	first = 1;
-+	for (;;) {
-+		num_pairs = 0;
-+		DUK__SETTEMP(comp_ctx, temp_start);
-+
-+		if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
-+			break;
-+		}
-+
-+		for (;;) {
-+			/*
-+			 *  Three possible element formats:
-+			 *    1) PropertyName : AssignmentExpression
-+			 *    2) get PropertyName () { FunctionBody }
-+			 *    3) set PropertyName ( PropertySetParameterList ) { FunctionBody }
-+			 *
-+			 *  PropertyName can be IdentifierName (includes reserved words), a string
-+			 *  literal, or a number literal.  Note that IdentifierName allows 'get' and
-+			 *  'set' too, so we need to look ahead to the next token to distinguish:
-+			 *
-+			 *     { get : 1 }
-+			 *
-+			 *  and
-+			 *
-+			 *     { get foo() { return 1 } }
-+			 *     { get get() { return 1 } }    // 'get' as getter propertyname
-+			 *
-+			 *  Finally, a trailing comma is allowed.
-+			 *
-+			 *  Key name is coerced to string at compile time (and ends up as a
-+			 *  a string constant) even for numeric keys (e.g. "{1:'foo'}").
-+			 *  These could be emitted using e.g. LDINT, but that seems hardly
-+			 *  worth the effort and would increase code size.
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("object literal inner loop, curr_token->t = %ld",
-+			                     (long) comp_ctx->curr_token.t));
-+
-+			if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
-+				/* the outer loop will recheck and exit */
-+				break;
-+			}
-+			if (num_pairs >= max_init_pairs) {
-+				/* MPUTOBJ emitted by outer loop */
-+				break;
-+			}
-+
-+			if (first) {
-+				first = 0;
-+			} else {
-+				if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
-+					goto syntax_error;
-+				}
-+				duk__advance(comp_ctx);
-+				if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
-+					/* trailing comma followed by rcurly */
-+					break;
-+				}
-+			}
-+
-+			/* advance to get one step of lookup */
-+			duk__advance(comp_ctx);
-+
-+			/* NOTE: "get" and "set" are not officially ReservedWords and the lexer
-+			 * currently treats them always like ordinary identifiers (DUK_TOK_GET
-+			 * and DUK_TOK_SET are unused).  They need to be detected based on the
-+			 * identifier string content.
-+			 */
-+
-+			is_get = (comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
-+			          comp_ctx->prev_token.str1 == DUK_HTHREAD_STRING_GET(thr));
-+			is_set = (comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
-+			          comp_ctx->prev_token.str1 == DUK_HTHREAD_STRING_SET(thr));
-+			if ((is_get || is_set) && comp_ctx->curr_token.t != DUK_TOK_COLON) {
-+				/* getter/setter */
-+				duk_int_t fnum;
-+
-+				if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER ||
-+				    comp_ctx->curr_token.t_nores == DUK_TOK_STRING) {
-+					/* same handling for identifiers and strings */
-+					DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
-+					duk_push_hstring(ctx, comp_ctx->curr_token.str1);
-+				} else if (comp_ctx->curr_token.t == DUK_TOK_NUMBER) {
-+					duk_push_number(ctx, comp_ctx->curr_token.num);
-+					duk_to_string(ctx, -1);
-+				} else {
-+					goto syntax_error;
-+				}
-+
-+				DUK_ASSERT(duk_is_string(ctx, -1));
-+				if (duk__nud_object_literal_key_check(comp_ctx,
-+				                                      (is_get ? DUK__OBJ_LIT_KEY_GET : DUK__OBJ_LIT_KEY_SET))) {
-+					goto syntax_error;
-+				}
-+				reg_key = duk__getconst(comp_ctx);
-+
-+				if (num_pairs > 0) {
-+					/* - A is a source register (it's not a write target, but used
-+					 *   to identify the target object) but can be shuffled.
-+					 * - B cannot be shuffled normally because it identifies a range
-+					 *   of registers, the emitter has special handling for this
-+					 *   (the "no shuffle" flag must not be set).
-+					 * - C is a non-register number and cannot be shuffled, but
-+					 *   never needs to be.
-+					 */
-+					duk__emit_a_b_c(comp_ctx,
-+					                DUK_OP_MPUTOBJ |
-+					                    DUK__EMIT_FLAG_NO_SHUFFLE_C |
-+					                    DUK__EMIT_FLAG_A_IS_SOURCE,
-+					                reg_obj,
-+					                temp_start,
-+					                num_pairs);
-+					num_pairs = 0;
-+					DUK__SETTEMP(comp_ctx, temp_start);
-+				}
-+
-+				/* curr_token = get/set name */
-+				fnum = duk__parse_func_like_fnum(comp_ctx, 0 /*is_decl*/, 1 /*is_setget*/);
-+
-+				DUK_ASSERT(DUK__GETTEMP(comp_ctx) == temp_start);
-+				reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_LDCONST,
-+				               (duk_regconst_t) reg_temp,
-+				               (duk_regconst_t) reg_key);
-+				reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_CLOSURE,
-+				               (duk_regconst_t) reg_temp,
-+				               (duk_regconst_t) fnum);
-+
-+				/* Slot C is used in a non-standard fashion (range of regs),
-+				 * emitter code has special handling for it (must not set the
-+				 * "no shuffle" flag).
-+				 */
-+				duk__emit_extraop_b_c(comp_ctx,
-+				                      (is_get ? DUK_EXTRAOP_INITGET : DUK_EXTRAOP_INITSET),
-+				                      reg_obj,
-+				                      temp_start);   /* temp_start+0 = key, temp_start+1 = closure */
-+
-+				DUK__SETTEMP(comp_ctx, temp_start);
-+			} else {
-+				/* normal key/value */
-+				if (comp_ctx->prev_token.t_nores == DUK_TOK_IDENTIFIER ||
-+				    comp_ctx->prev_token.t_nores == DUK_TOK_STRING) {
-+					/* same handling for identifiers and strings */
-+					DUK_ASSERT(comp_ctx->prev_token.str1 != NULL);
-+					duk_push_hstring(ctx, comp_ctx->prev_token.str1);
-+				} else if (comp_ctx->prev_token.t == DUK_TOK_NUMBER) {
-+					duk_push_number(ctx, comp_ctx->prev_token.num);
-+					duk_to_string(ctx, -1);
-+				} else {
-+					goto syntax_error;
-+				}
-+
-+				DUK_ASSERT(duk_is_string(ctx, -1));
-+				if (duk__nud_object_literal_key_check(comp_ctx, DUK__OBJ_LIT_KEY_PLAIN)) {
-+					goto syntax_error;
-+				}
-+				reg_key = duk__getconst(comp_ctx);
-+
-+				reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_LDCONST,
-+				               (duk_regconst_t) reg_temp,
-+				               (duk_regconst_t) reg_key);
-+				duk__advance_expect(comp_ctx, DUK_TOK_COLON);
-+
-+				reg_temp = DUK__ALLOCTEMP(comp_ctx);  /* alloc temp just in case, to update max temp */
-+				DUK__SETTEMP(comp_ctx, reg_temp);
-+				duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);
-+				DUK__SETTEMP(comp_ctx, reg_temp + 1);
-+
-+				num_pairs++;
-+			}
-+		}
-+
-+		if (num_pairs > 0) {
-+			/* See MPUTOBJ comments above. */
-+			duk__emit_a_b_c(comp_ctx,
-+			                DUK_OP_MPUTOBJ |
-+			                    DUK__EMIT_FLAG_NO_SHUFFLE_C |
-+			                    DUK__EMIT_FLAG_A_IS_SOURCE,
-+			                reg_obj,
-+			                temp_start,
-+			                num_pairs);
-+
-+			/* num_pairs and temp_start reset at top of outer loop */
-+		}
-+	}
-+
-+	DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RCURLY);
-+	duk__advance(comp_ctx);
-+
-+	DUK__SETTEMP(comp_ctx, temp_start);
-+
-+	res->t = DUK_IVAL_PLAIN;
-+	res->x1.t = DUK_ISPEC_REGCONST;
-+	res->x1.regconst = (duk_regconst_t) reg_obj;
-+
-+	DUK_DDD(DUK_DDDPRINT("final tracking object: %!T",
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+	duk_pop(ctx);
-+	return;
-+
-+ syntax_error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_OBJECT_LITERAL);
-+}
-+
-+/* Parse argument list.  Arguments are written to temps starting from
-+ * "next temp".  Returns number of arguments parsed.  Expects left paren
-+ * to be already eaten, and eats the right paren before returning.
-+ */
-+DUK_LOCAL duk_int_t duk__parse_arguments(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_int_t nargs = 0;
-+	duk_reg_t reg_temp;
-+
-+	/* Note: expect that caller has already eaten the left paren */
-+
-+	DUK_DDD(DUK_DDDPRINT("start parsing arguments, prev_token.t=%ld, curr_token.t=%ld",
-+	                     (long) comp_ctx->prev_token.t, (long) comp_ctx->curr_token.t));
-+
-+	for (;;) {
-+		if (comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
-+			break;
-+		}
-+		if (nargs > 0) {
-+			duk__advance_expect(comp_ctx, DUK_TOK_COMMA);
-+		}
-+
-+		/* We want the argument expression value to go to "next temp"
-+		 * without additional moves.  That should almost always be the
-+		 * case, but we double check after expression parsing.
-+		 *
-+		 * This is not the cleanest possible approach.
-+		 */
-+
-+		reg_temp = DUK__ALLOCTEMP(comp_ctx);  /* bump up "allocated" reg count, just in case */
-+		DUK__SETTEMP(comp_ctx, reg_temp);
-+
-+		/* binding power must be high enough to NOT allow comma expressions directly */
-+		duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp);  /* always allow 'in', coerce to 'tr' just in case */
-+
-+		DUK__SETTEMP(comp_ctx, reg_temp + 1);
-+		nargs++;
-+
-+		DUK_DDD(DUK_DDDPRINT("argument #%ld written into reg %ld", (long) nargs, (long) reg_temp));
-+	}
-+
-+	/* eat the right paren */
-+	duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+
-+	DUK_DDD(DUK_DDDPRINT("end parsing arguments"));
-+
-+	return nargs;
-+}
-+
-+DUK_LOCAL duk_bool_t duk__expr_is_empty(duk_compiler_ctx *comp_ctx) {
-+	/* empty expressions can be detected conveniently with nud/led counts */
-+	return (comp_ctx->curr_func.nud_count == 0) &&
-+	       (comp_ctx->curr_func.led_count == 0);
-+}
-+
-+DUK_LOCAL void duk__expr_nud(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_token *tk;
-+	duk_reg_t temp_at_entry;
-+	duk_small_int_t tok;
-+	duk_uint32_t args;  /* temp variable to pass constants and flags to shared code */
-+
-+	/*
-+	 *  ctx->prev_token     token to process with duk__expr_nud()
-+	 *  ctx->curr_token     updated by caller
-+	 *
-+	 *  Note: the token in the switch below has already been eaten.
-+	 */
-+
-+	temp_at_entry = DUK__GETTEMP(comp_ctx);
-+
-+	comp_ctx->curr_func.nud_count++;
-+
-+	tk = &comp_ctx->prev_token;
-+	tok = tk->t;
-+	res->t = DUK_IVAL_NONE;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__expr_nud(), prev_token.t=%ld, allow_in=%ld, paren_level=%ld",
-+	                     (long) tk->t, (long) comp_ctx->curr_func.allow_in, (long) comp_ctx->curr_func.paren_level));
-+
-+	switch (tok) {
-+
-+	/* PRIMARY EXPRESSIONS */
-+
-+	case DUK_TOK_THIS: {
-+		duk_reg_t reg_temp;
-+		reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+		duk__emit_extraop_bc(comp_ctx,
-+		                     DUK_EXTRAOP_LDTHIS,
-+		                     (duk_regconst_t) reg_temp);
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_temp;
-+		return;
-+	}
-+	case DUK_TOK_IDENTIFIER: {
-+		res->t = DUK_IVAL_VAR;
-+		res->x1.t = DUK_ISPEC_VALUE;
-+		duk_push_hstring(ctx, tk->str1);
-+		duk_replace(ctx, res->x1.valstack_idx);
-+		return;
-+	}
-+	case DUK_TOK_NULL: {
-+		duk_push_null(ctx);
-+		goto plain_value;
-+	}
-+	case DUK_TOK_TRUE: {
-+		duk_push_true(ctx);
-+		goto plain_value;
-+	}
-+	case DUK_TOK_FALSE: {
-+		duk_push_false(ctx);
-+		goto plain_value;
-+	}
-+	case DUK_TOK_NUMBER: {
-+		duk_push_number(ctx, tk->num);
-+		goto plain_value;
-+	}
-+	case DUK_TOK_STRING: {
-+		DUK_ASSERT(tk->str1 != NULL);
-+		duk_push_hstring(ctx, tk->str1);
-+		goto plain_value;
-+	}
-+	case DUK_TOK_REGEXP: {
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+		duk_reg_t reg_temp;
-+		duk_regconst_t rc_re_bytecode;  /* const */
-+		duk_regconst_t rc_re_source;    /* const */
-+
-+		DUK_ASSERT(tk->str1 != NULL);
-+		DUK_ASSERT(tk->str2 != NULL);
-+
-+		DUK_DDD(DUK_DDDPRINT("emitting regexp op, str1=%!O, str2=%!O",
-+		                     (duk_heaphdr *) tk->str1,
-+		                     (duk_heaphdr *) tk->str2));
-+
-+		reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+		duk_push_hstring(ctx, tk->str1);
-+		duk_push_hstring(ctx, tk->str2);
-+
-+		/* [ ... pattern flags ] */
-+
-+		duk_regexp_compile(thr);
-+
-+		/* [ ... escaped_source bytecode ] */
-+
-+		rc_re_bytecode = duk__getconst(comp_ctx);
-+		rc_re_source = duk__getconst(comp_ctx);
-+
-+		duk__emit_a_b_c(comp_ctx,
-+		                DUK_OP_REGEXP,
-+		                (duk_regconst_t) reg_temp /*a*/,
-+		                rc_re_bytecode /*b*/,
-+		                rc_re_source /*c*/);
-+
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_temp;
-+		return;
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+		goto syntax_error;
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+	}
-+	case DUK_TOK_LBRACKET: {
-+		DUK_DDD(DUK_DDDPRINT("parsing array literal"));
-+		duk__nud_array_literal(comp_ctx, res);
-+		return;
-+	}
-+	case DUK_TOK_LCURLY: {
-+		DUK_DDD(DUK_DDDPRINT("parsing object literal"));
-+		duk__nud_object_literal(comp_ctx, res);
-+		return;
-+	}
-+	case DUK_TOK_LPAREN: {
-+		duk_bool_t prev_allow_in;
-+
-+		comp_ctx->curr_func.paren_level++;
-+		prev_allow_in = comp_ctx->curr_func.allow_in;
-+		comp_ctx->curr_func.allow_in = 1; /* reset 'allow_in' for parenthesized expression */
-+
-+		duk__expr(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);  /* Expression, terminates at a ')' */
-+
-+		duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+		comp_ctx->curr_func.allow_in = prev_allow_in;
-+		comp_ctx->curr_func.paren_level--;
-+		return;
-+	}
-+
-+	/* MEMBER/NEW/CALL EXPRESSIONS */
-+
-+	case DUK_TOK_NEW: {
-+		/*
-+		 *  Parsing an expression starting with 'new' is tricky because
-+		 *  there are multiple possible productions deriving from
-+		 *  LeftHandSideExpression which begin with 'new'.
-+		 *
-+		 *  We currently resort to one-token lookahead to distinguish the
-+		 *  cases.  Hopefully this is correct.  The binding power must be
-+		 *  such that parsing ends at an LPAREN (CallExpression) but not at
-+		 *  a PERIOD or LBRACKET (MemberExpression).
-+		 *
-+		 *  See doc/compiler.txt for discussion on the parsing approach,
-+		 *  and testcases/test-dev-new.js for a bunch of documented tests.
-+		 */
-+
-+		duk_reg_t reg_target;
-+		duk_int_t nargs;
-+
-+		DUK_DDD(DUK_DDDPRINT("begin parsing new expression"));
-+
-+		reg_target = DUK__ALLOCTEMP(comp_ctx);
-+		duk__expr_toforcedreg(comp_ctx, res, DUK__BP_CALL /*rbp_flags*/, reg_target /*forced_reg*/);
-+		DUK__SETTEMP(comp_ctx, reg_target + 1);
-+
-+		if (comp_ctx->curr_token.t == DUK_TOK_LPAREN) {
-+			/* 'new' MemberExpression Arguments */
-+			DUK_DDD(DUK_DDDPRINT("new expression has argument list"));
-+			duk__advance(comp_ctx);
-+			nargs = duk__parse_arguments(comp_ctx, res);  /* parse args starting from "next temp", reg_target + 1 */
-+			/* right paren eaten */
-+		} else {
-+			/* 'new' MemberExpression */
-+			DUK_DDD(DUK_DDDPRINT("new expression has no argument list"));
-+			nargs = 0;
-+		}
-+
-+		/* Opcode slot C is used in a non-standard way, so shuffling
-+		 * is not allowed.
-+		 */
-+		duk__emit_a_b_c(comp_ctx,
-+		              DUK_OP_NEW | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C,
-+		              0 /*unused*/,
-+		              reg_target /*target*/,
-+		              nargs /*num_args*/);
-+
-+		DUK_DDD(DUK_DDDPRINT("end parsing new expression"));
-+
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_target;
-+		return;
-+	}
-+
-+	/* FUNCTION EXPRESSIONS */
-+
-+	case DUK_TOK_FUNCTION: {
-+		/* Function expression.  Note that any statement beginning with 'function'
-+		 * is handled by the statement parser as a function declaration, or a
-+		 * non-standard function expression/statement (or a SyntaxError).  We only
-+		 * handle actual function expressions (occurring inside an expression) here.
-+		 *
-+		 * O(depth^2) parse count for inner functions is handled by recording a
-+		 * lexer offset on the first compilation pass, so that the function can
-+		 * be efficiently skipped on the second pass.  This is encapsulated into
-+		 * duk__parse_func_like_fnum().
-+		 */
-+
-+		duk_reg_t reg_temp;
-+		duk_int_t fnum;
-+
-+		reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+
-+		/* curr_token follows 'function' */
-+		fnum = duk__parse_func_like_fnum(comp_ctx, 0 /*is_decl*/, 0 /*is_setget*/);
-+		DUK_DDD(DUK_DDDPRINT("parsed inner function -> fnum %ld", (long) fnum));
-+
-+		duk__emit_a_bc(comp_ctx,
-+		               DUK_OP_CLOSURE,
-+		               (duk_regconst_t) reg_temp /*a*/,
-+		               (duk_regconst_t) fnum /*bc*/);
-+
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_temp;
-+		return;
-+	}
-+
-+	/* UNARY EXPRESSIONS */
-+
-+	case DUK_TOK_DELETE: {
-+		/* Delete semantics are a bit tricky.  The description in E5 specification
-+		 * is kind of confusing, because it distinguishes between resolvability of
-+		 * a reference (which is only known at runtime) seemingly at compile time
-+		 * (= SyntaxError throwing).
-+		 */
-+		duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
-+		if (res->t == DUK_IVAL_VAR) {
-+			/* not allowed in strict mode, regardless of whether resolves;
-+			 * in non-strict mode DELVAR handles both non-resolving and
-+			 * resolving cases (the specification description is a bit confusing).
-+			 */
-+
-+			duk_reg_t reg_temp;
-+			duk_reg_t reg_varbind;
-+			duk_regconst_t rc_varname;
-+
-+			if (comp_ctx->curr_func.is_strict) {
-+				DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_CANNOT_DELETE_IDENTIFIER);
-+			}
-+
-+			DUK__SETTEMP(comp_ctx, temp_at_entry);
-+			reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+
-+			duk_dup(ctx, res->x1.valstack_idx);
-+			if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
-+				/* register bound variables are non-configurable -> always false */
-+				duk__emit_extraop_bc(comp_ctx,
-+				                     DUK_EXTRAOP_LDFALSE,
-+				                     (duk_regconst_t) reg_temp);
-+			} else {
-+				duk_dup(ctx, res->x1.valstack_idx);
-+				rc_varname = duk__getconst(comp_ctx);
-+				duk__emit_a_b(comp_ctx,
-+				              DUK_OP_DELVAR,
-+				              (duk_regconst_t) reg_temp,
-+				              (duk_regconst_t) rc_varname);
-+			}
-+			res->t = DUK_IVAL_PLAIN;
-+			res->x1.t = DUK_ISPEC_REGCONST;
-+			res->x1.regconst = (duk_regconst_t) reg_temp;
-+		} else if (res->t == DUK_IVAL_PROP) {
-+			duk_reg_t reg_temp;
-+			duk_reg_t reg_obj;
-+			duk_regconst_t rc_key;
-+
-+			DUK__SETTEMP(comp_ctx, temp_at_entry);
-+			reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+			reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/);  /* don't allow const */
-+			rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
-+			duk__emit_a_b_c(comp_ctx,
-+			                DUK_OP_DELPROP,
-+			                (duk_regconst_t) reg_temp,
-+			                (duk_regconst_t) reg_obj,
-+			                rc_key);
-+
-+			res->t = DUK_IVAL_PLAIN;
-+			res->x1.t = DUK_ISPEC_REGCONST;
-+			res->x1.regconst = (duk_regconst_t) reg_temp;
-+		} else {
-+			/* non-Reference deletion is always 'true', even in strict mode */
-+			duk_push_true(ctx);
-+			goto plain_value;
-+		}
-+		return;
-+	}
-+	case DUK_TOK_VOID: {
-+		duk__expr_toplain_ignore(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
-+		duk_push_undefined(ctx);
-+		goto plain_value;
-+	}
-+	case DUK_TOK_TYPEOF: {
-+		/* 'typeof' must handle unresolvable references without throwing
-+		 * a ReferenceError (E5 Section 11.4.3).  Register mapped values
-+		 * will never be unresolvable so special handling is only required
-+		 * when an identifier is a "slow path" one.
-+		 */
-+		duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
-+
-+		if (res->t == DUK_IVAL_VAR) {
-+			duk_reg_t reg_varbind;
-+			duk_regconst_t rc_varname;
-+			duk_reg_t reg_temp;
-+
-+			duk_dup(ctx, res->x1.valstack_idx);
-+			if (!duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
-+				DUK_DDD(DUK_DDDPRINT("typeof for an identifier name which could not be resolved "
-+				                     "at compile time, need to use special run-time handling"));
-+				reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+				duk__emit_extraop_b_c(comp_ctx,
-+				                      DUK_EXTRAOP_TYPEOFID | DUK__EMIT_FLAG_B_IS_TARGET,
-+				                      reg_temp,
-+				                      rc_varname);
-+				res->t = DUK_IVAL_PLAIN;
-+				res->x1.t = DUK_ISPEC_REGCONST;
-+				res->x1.regconst = (duk_regconst_t) reg_temp;
-+				return;
-+			}
-+		}
-+
-+		args = (DUK_EXTRAOP_TYPEOF << 8) + 0;
-+		goto unary_extraop;
-+	}
-+	case DUK_TOK_INCREMENT: {
-+		args = (DUK_OP_PREINCR << 8) + 0;
-+		goto preincdec;
-+	}
-+	case DUK_TOK_DECREMENT: {
-+		args = (DUK_OP_PREDECR << 8) + 0;
-+		goto preincdec;
-+	}
-+	case DUK_TOK_ADD: {
-+		/* unary plus */
-+		duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
-+		if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE &&
-+		    duk_is_number(ctx, res->x1.valstack_idx)) {
-+			/* unary plus of a number is identity */
-+			;
-+			return;
-+		}
-+		args = (DUK_EXTRAOP_UNP << 8) + 0;
-+		goto unary_extraop;
-+	}
-+	case DUK_TOK_SUB: {
-+		/* unary minus */
-+		duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
-+		if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE &&
-+		    duk_is_number(ctx, res->x1.valstack_idx)) {
-+			/* this optimization is important to handle negative literals (which are not directly
-+			 * provided by the lexical grammar
-+			 */
-+			duk_tval *tv_num = duk_get_tval(ctx, res->x1.valstack_idx);
-+			duk_double_union du;
-+
-+			DUK_ASSERT(tv_num != NULL);
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_num));
-+			du.d = DUK_TVAL_GET_NUMBER(tv_num);
-+			du.d = -du.d;
-+			DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
-+			DUK_TVAL_SET_NUMBER(tv_num, du.d);
-+			return;
-+		}
-+		args = (DUK_EXTRAOP_UNM << 8) + 0;
-+		goto unary_extraop;
-+	}
-+	case DUK_TOK_BNOT: {
-+		duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
-+		args = (DUK_EXTRAOP_BNOT << 8) + 0;
-+		goto unary_extraop;
-+	}
-+	case DUK_TOK_LNOT: {
-+		duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
-+		if (res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_VALUE) {
-+			/* Very minimal inlining to handle common idioms '!0' and '!1',
-+			 * and also boolean arguments like '!false' and '!true'.
-+			 */
-+			duk_tval *tv_val = duk_get_tval(ctx, res->x1.valstack_idx);
-+
-+			DUK_ASSERT(tv_val != NULL);
-+			if (DUK_TVAL_IS_NUMBER(tv_val)) {
-+				duk_double_t d;
-+				d = DUK_TVAL_GET_NUMBER(tv_val);
-+				if (d == 0.0) {
-+					/* Matches both +0 and -0 on purpose. */
-+					DUK_DDD(DUK_DDDPRINT("inlined lnot: !0 -> true"));
-+					DUK_TVAL_SET_BOOLEAN_TRUE(tv_val);
-+					return;
-+				} else if (d == 1.0) {
-+					DUK_DDD(DUK_DDDPRINT("inlined lnot: !1 -> false"));
-+					DUK_TVAL_SET_BOOLEAN_FALSE(tv_val);
-+					return;
-+				}
-+			} else if (DUK_TVAL_IS_BOOLEAN(tv_val)) {
-+				duk_small_int_t v;
-+				v = DUK_TVAL_GET_BOOLEAN(tv_val);
-+				DUK_DDD(DUK_DDDPRINT("inlined lnot boolean: %ld", (long) v));
-+				DUK_ASSERT(v == 0 || v == 1);
-+				DUK_TVAL_SET_BOOLEAN(tv_val, v ^ 0x01);
-+				return;
-+			}
-+		}
-+		args = (DUK_EXTRAOP_LNOT << 8) + 0;
-+		goto unary_extraop;
-+	}
-+
-+	}  /* end switch */
-+
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_PARSE_ERROR);
-+	return;
-+
-+ unary_extraop:
-+	{
-+		/* Note: must coerce to a (writable) temp register, so that e.g. "!x" where x
-+		 * is a reg-mapped variable works correctly (does not mutate the variable register).
-+		 */
-+
-+		duk_reg_t reg_temp;
-+		reg_temp = duk__ivalue_toregconst_raw(comp_ctx, res, -1 /*forced_reg*/, DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/);
-+		duk__emit_extraop_bc(comp_ctx,
-+		                     (args >> 8),
-+		                     (duk_regconst_t) reg_temp);
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_temp;
-+		return;
-+	}
-+
-+ preincdec:
-+	{
-+		/* preincrement and predecrement */
-+		duk_reg_t reg_res;
-+		duk_small_uint_t args_op = args >> 8;
-+
-+		/* Specific assumptions for opcode numbering. */
-+		DUK_ASSERT(DUK_OP_PREINCR + 4 == DUK_OP_PREINCV);
-+		DUK_ASSERT(DUK_OP_PREDECR + 4 == DUK_OP_PREDECV);
-+		DUK_ASSERT(DUK_OP_PREINCR + 8 == DUK_OP_PREINCP);
-+		DUK_ASSERT(DUK_OP_PREDECR + 8 == DUK_OP_PREDECP);
-+
-+		reg_res = DUK__ALLOCTEMP(comp_ctx);
-+
-+		duk__expr(comp_ctx, res, DUK__BP_MULTIPLICATIVE /*rbp_flags*/);  /* UnaryExpression */
-+		if (res->t == DUK_IVAL_VAR) {
-+			duk_hstring *h_varname;
-+			duk_reg_t reg_varbind;
-+			duk_regconst_t rc_varname;
-+
-+			h_varname = duk_get_hstring(ctx, res->x1.valstack_idx);
-+			DUK_ASSERT(h_varname != NULL);
-+
-+			if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
-+				goto syntax_error;
-+			}
-+
-+			duk_dup(ctx, res->x1.valstack_idx);
-+			if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
-+				duk__emit_a_bc(comp_ctx,
-+				               args_op,  /* e.g. DUK_OP_PREINCR */
-+				               (duk_regconst_t) reg_res,
-+				               (duk_regconst_t) reg_varbind);
-+			} else {
-+				duk__emit_a_bc(comp_ctx,
-+				                args_op + 4,  /* e.g. DUK_OP_PREINCV */
-+				                (duk_regconst_t) reg_res,
-+				                rc_varname);
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("preincdec to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
-+			                     (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
-+		} else if (res->t == DUK_IVAL_PROP) {
-+			duk_reg_t reg_obj;  /* allocate to reg only (not const) */
-+			duk_regconst_t rc_key;
-+			reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/);  /* don't allow const */
-+			rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
-+			duk__emit_a_b_c(comp_ctx,
-+			                args_op + 8,  /* e.g. DUK_OP_PREINCP */
-+			                (duk_regconst_t) reg_res,
-+			                (duk_regconst_t) reg_obj,
-+			                rc_key);
-+		} else {
-+			/* Technically return value is not needed because INVLHS will
-+			 * unconditially throw a ReferenceError.  Coercion is necessary
-+			 * for proper semantics (consider ToNumber() called for an object).
-+			 * Use DUK_EXTRAOP_UNP with a dummy register to get ToNumber().
-+			 */
-+
-+			duk__ivalue_toforcedreg(comp_ctx, res, reg_res);
-+			duk__emit_extraop_bc(comp_ctx,
-+			                     DUK_EXTRAOP_UNP,
-+			                     reg_res);  /* for side effects, result ignored */
-+			duk__emit_extraop_only(comp_ctx,
-+			                       DUK_EXTRAOP_INVLHS);
-+		}
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_res;
-+		DUK__SETTEMP(comp_ctx, reg_res + 1);
-+		return;
-+	}
-+
-+ plain_value:
-+	{
-+		/* Stack top contains plain value */
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_VALUE;
-+		duk_replace(ctx, res->x1.valstack_idx);
-+		return;
-+	}
-+
-+ syntax_error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_EXPRESSION);
-+}
-+
-+/* XXX: add flag to indicate whether caller cares about return value; this
-+ * affects e.g. handling of assignment expressions.  This change needs API
-+ * changes elsewhere too.
-+ */
-+DUK_LOCAL void duk__expr_led(duk_compiler_ctx *comp_ctx, duk_ivalue *left, duk_ivalue *res) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_token *tk;
-+	duk_small_int_t tok;
-+	duk_uint32_t args;  /* temp variable to pass constants and flags to shared code */
-+
-+	/*
-+	 *  ctx->prev_token     token to process with duk__expr_led()
-+	 *  ctx->curr_token     updated by caller
-+	 */
-+
-+	comp_ctx->curr_func.led_count++;
-+
-+	/* The token in the switch has already been eaten here */
-+	tk = &comp_ctx->prev_token;
-+	tok = tk->t;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__expr_led(), prev_token.t=%ld, allow_in=%ld, paren_level=%ld",
-+	                     (long) tk->t, (long) comp_ctx->curr_func.allow_in, (long) comp_ctx->curr_func.paren_level));
-+
-+	/* XXX: default priority for infix operators is duk__expr_lbp(tok) -> get it here? */
-+
-+	switch (tok) {
-+
-+	/* PRIMARY EXPRESSIONS */
-+
-+	case DUK_TOK_PERIOD: {
-+		/* Property access expressions are critical for correct LHS ordering,
-+		 * see comments in duk__expr()!
-+		 */
-+
-+		/* XXX: this now coerces an identifier into a GETVAR to a temp, which
-+		 * causes an extra LDREG in call setup.  It's sufficient to coerce to a
-+		 * unary ivalue?
-+		 */
-+		duk__ivalue_toplain(comp_ctx, left);
-+
-+		/* NB: must accept reserved words as property name */
-+		if (comp_ctx->curr_token.t_nores != DUK_TOK_IDENTIFIER) {
-+			DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_EXPECTED_IDENTIFIER);
-+		}
-+
-+		res->t = DUK_IVAL_PROP;
-+		duk__copy_ispec(comp_ctx, &left->x1, &res->x1);  /* left.x1 -> res.x1 */
-+		DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
-+		duk_push_hstring(ctx, comp_ctx->curr_token.str1);
-+		duk_replace(ctx, res->x2.valstack_idx);
-+		res->x2.t = DUK_ISPEC_VALUE;
-+
-+		/* special RegExp literal handling after IdentifierName */
-+		comp_ctx->curr_func.reject_regexp_in_adv = 1;
-+
-+		duk__advance(comp_ctx);
-+		return;
-+	}
-+	case DUK_TOK_LBRACKET: {
-+		/* Property access expressions are critical for correct LHS ordering,
-+		 * see comments in duk__expr()!
-+		 */
-+
-+		/* XXX: optimize temp reg use */
-+		/* XXX: similar coercion issue as in DUK_TOK_PERIOD */
-+
-+		/* XXX: coerce to regs? it might be better for enumeration use, where the
-+		 * same PROP ivalue is used multiple times.  Or perhaps coerce PROP further
-+		 * there?
-+		 */
-+
-+		duk__ivalue_toplain(comp_ctx, left);
-+		duk__expr_toplain(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);  /* Expression, ']' terminates */
-+		duk__advance_expect(comp_ctx, DUK_TOK_RBRACKET);
-+
-+		res->t = DUK_IVAL_PROP;
-+		duk__copy_ispec(comp_ctx, &res->x1, &res->x2);   /* res.x1 -> res.x2 */
-+		duk__copy_ispec(comp_ctx, &left->x1, &res->x1);  /* left.x1 -> res.x1 */
-+		return;
-+	}
-+	case DUK_TOK_LPAREN: {
-+		/* function call */
-+		duk_reg_t reg_cs = DUK__ALLOCTEMPS(comp_ctx, 2);
-+		duk_int_t nargs;
-+		duk_small_uint_t call_flags = 0;
-+
-+		/*
-+		 *  XXX: attempt to get the call result to "next temp" whenever
-+		 *  possible to avoid unnecessary register shuffles.
-+		 *
-+		 *  XXX: CSPROP (and CSREG) can overwrite the call target register, and save one temp,
-+		 *  if the call target is a temporary register and at the top of the temp reg "stack".
-+		 */
-+
-+		/*
-+		 *  Setup call: target and 'this' binding.  Three cases:
-+		 *
-+		 *    1. Identifier base (e.g. "foo()")
-+		 *    2. Property base (e.g. "foo.bar()")
-+		 *    3. Register base (e.g. "foo()()"; i.e. when a return value is a function)
-+		 */
-+
-+		if (left->t == DUK_IVAL_VAR) {
-+			duk_hstring *h_varname;
-+			duk_reg_t reg_varbind;
-+			duk_regconst_t rc_varname;
-+
-+			DUK_DDD(DUK_DDDPRINT("function call with identifier base"));
-+
-+			h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
-+			DUK_ASSERT(h_varname != NULL);
-+			if (h_varname == DUK_HTHREAD_STRING_EVAL(thr)) {
-+				/* Potential direct eval call detected, flag the CALL
-+				 * so that a run-time "direct eval" check is made and
-+				 * special behavior may be triggered.  Note that this
-+				 * does not prevent 'eval' from being register bound.
-+				 */
-+				DUK_DDD(DUK_DDDPRINT("function call with identifier 'eval' "
-+				                     "-> enabling EVALCALL flag, marking function "
-+				                     "as may_direct_eval"));
-+				call_flags |= DUK_BC_CALL_FLAG_EVALCALL;
-+
-+				comp_ctx->curr_func.may_direct_eval = 1;
-+			}
-+
-+			duk_dup(ctx, left->x1.valstack_idx);
-+			if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
-+				duk__emit_a_b(comp_ctx,
-+				              DUK_OP_CSREG,
-+				              (duk_regconst_t) (reg_cs + 0),
-+				              (duk_regconst_t) reg_varbind);
-+			} else {
-+				duk__emit_a_b(comp_ctx,
-+				              DUK_OP_CSVAR,
-+				              (duk_regconst_t) (reg_cs + 0),
-+				              rc_varname);
-+			}
-+		} else if (left->t == DUK_IVAL_PROP) {
-+			DUK_DDD(DUK_DDDPRINT("function call with property base"));
-+
-+			duk__ispec_toforcedreg(comp_ctx, &left->x1, reg_cs + 0);  /* base */
-+			duk__ispec_toforcedreg(comp_ctx, &left->x2, reg_cs + 1);  /* key */
-+			duk__emit_a_b_c(comp_ctx,
-+			                DUK_OP_CSPROP,
-+			                (duk_regconst_t) (reg_cs + 0),
-+			                (duk_regconst_t) (reg_cs + 0),
-+			                (duk_regconst_t) (reg_cs + 1));  /* in-place setup */
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("function call with register base"));
-+
-+			duk__ivalue_toforcedreg(comp_ctx, left, reg_cs + 0);
-+			duk__emit_a_b(comp_ctx,
-+			              DUK_OP_CSREG,
-+			              (duk_regconst_t) (reg_cs + 0),
-+			              (duk_regconst_t) (reg_cs + 0));  /* in-place setup */
-+		}
-+
-+		DUK__SETTEMP(comp_ctx, reg_cs + 2);
-+		nargs = duk__parse_arguments(comp_ctx, res);  /* parse args starting from "next temp" */
-+
-+		/* Tailcalls are handled by back-patching the TAILCALL flag to the
-+		 * already emitted instruction later (in return statement parser).
-+		 * Since A and C have a special meaning here, they cannot be "shuffled".
-+		 */
-+
-+		duk__emit_a_b_c(comp_ctx,
-+		                DUK_OP_CALL | DUK__EMIT_FLAG_NO_SHUFFLE_A | DUK__EMIT_FLAG_NO_SHUFFLE_C,
-+		                (duk_regconst_t) call_flags /*flags*/,
-+		                (duk_regconst_t) reg_cs /*basereg*/,
-+		                (duk_regconst_t) nargs /*numargs*/);
-+		DUK__SETTEMP(comp_ctx, reg_cs + 1);    /* result in csreg */
-+
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_cs;
-+		return;
-+	}
-+
-+	/* POSTFIX EXPRESSION */
-+
-+	case DUK_TOK_INCREMENT: {
-+		args = (DUK_OP_POSTINCR << 8) + 0;
-+		goto postincdec;
-+	}
-+	case DUK_TOK_DECREMENT: {
-+		args = (DUK_OP_POSTDECR << 8) + 0;
-+		goto postincdec;
-+	}
-+
-+	/* MULTIPLICATIVE EXPRESSION */
-+
-+	case DUK_TOK_MUL: {
-+		args = (DUK_OP_MUL << 8) + DUK__BP_MULTIPLICATIVE;  /* UnaryExpression */
-+		goto binary;
-+	}
-+	case DUK_TOK_DIV: {
-+		args = (DUK_OP_DIV << 8) + DUK__BP_MULTIPLICATIVE;  /* UnaryExpression */
-+		goto binary;
-+	}
-+	case DUK_TOK_MOD: {
-+		args = (DUK_OP_MOD << 8) + DUK__BP_MULTIPLICATIVE;  /* UnaryExpression */
-+		goto binary;
-+	}
-+
-+	/* ADDITIVE EXPRESSION */
-+
-+	case DUK_TOK_ADD: {
-+		args = (DUK_OP_ADD << 8) + DUK__BP_ADDITIVE;  /* MultiplicativeExpression */
-+		goto binary;
-+	}
-+	case DUK_TOK_SUB: {
-+		args = (DUK_OP_SUB << 8) + DUK__BP_ADDITIVE;  /* MultiplicativeExpression */
-+		goto binary;
-+	}
-+
-+	/* SHIFT EXPRESSION */
-+
-+	case DUK_TOK_ALSHIFT: {
-+		/* << */
-+		args = (DUK_OP_BASL << 8) + DUK__BP_SHIFT;
-+		goto binary;
-+	}
-+	case DUK_TOK_ARSHIFT: {
-+		/* >> */
-+		args = (DUK_OP_BASR << 8) + DUK__BP_SHIFT;
-+		goto binary;
-+	}
-+	case DUK_TOK_RSHIFT: {
-+		/* >>> */
-+		args = (DUK_OP_BLSR << 8) + DUK__BP_SHIFT;
-+		goto binary;
-+	}
-+
-+	/* RELATIONAL EXPRESSION */
-+
-+	case DUK_TOK_LT: {
-+		/* < */
-+		args = (DUK_OP_LT << 8) + DUK__BP_RELATIONAL;
-+		goto binary;
-+	}
-+	case DUK_TOK_GT: {
-+		args = (DUK_OP_GT << 8) + DUK__BP_RELATIONAL;
-+		goto binary;
-+	}
-+	case DUK_TOK_LE: {
-+		args = (DUK_OP_LE << 8) + DUK__BP_RELATIONAL;
-+		goto binary;
-+	}
-+	case DUK_TOK_GE: {
-+		args = (DUK_OP_GE << 8) + DUK__BP_RELATIONAL;
-+		goto binary;
-+	}
-+	case DUK_TOK_INSTANCEOF: {
-+		args = (1 << 16 /*is_extra*/) + (DUK_EXTRAOP_INSTOF << 8) + DUK__BP_RELATIONAL;
-+		goto binary;
-+	}
-+	case DUK_TOK_IN: {
-+		args = (1 << 16 /*is_extra*/) + (DUK_EXTRAOP_IN << 8) + DUK__BP_RELATIONAL;
-+		goto binary;
-+	}
-+
-+	/* EQUALITY EXPRESSION */
-+
-+	case DUK_TOK_EQ: {
-+		args = (DUK_OP_EQ << 8) + DUK__BP_EQUALITY;
-+		goto binary;
-+	}
-+	case DUK_TOK_NEQ: {
-+		args = (DUK_OP_NEQ << 8) + DUK__BP_EQUALITY;
-+		goto binary;
-+	}
-+	case DUK_TOK_SEQ: {
-+		args = (DUK_OP_SEQ << 8) + DUK__BP_EQUALITY;
-+		goto binary;
-+	}
-+	case DUK_TOK_SNEQ: {
-+		args = (DUK_OP_SNEQ << 8) + DUK__BP_EQUALITY;
-+		goto binary;
-+	}
-+
-+	/* BITWISE EXPRESSIONS */
-+
-+	case DUK_TOK_BAND: {
-+		args = (DUK_OP_BAND << 8) + DUK__BP_BAND;
-+		goto binary;
-+	}
-+	case DUK_TOK_BXOR: {
-+		args = (DUK_OP_BXOR << 8) + DUK__BP_BXOR;
-+		goto binary;
-+	}
-+	case DUK_TOK_BOR: {
-+		args = (DUK_OP_BOR << 8) + DUK__BP_BOR;
-+		goto binary;
-+	}
-+
-+	/* LOGICAL EXPRESSIONS */
-+
-+	case DUK_TOK_LAND: {
-+		/* syntactically left-associative but parsed as right-associative */
-+		args = (1 << 8) + DUK__BP_LAND - 1;
-+		goto binary_logical;
-+	}
-+	case DUK_TOK_LOR: {
-+		/* syntactically left-associative but parsed as right-associative */
-+		args = (0 << 8) + DUK__BP_LOR - 1;
-+		goto binary_logical;
-+	}
-+
-+	/* CONDITIONAL EXPRESSION */
-+
-+	case DUK_TOK_QUESTION: {
-+		/* XXX: common reg allocation need is to reuse a sub-expression's temp reg,
-+		 * but only if it really is a temp.  Nothing fancy here now.
-+		 */
-+		duk_reg_t reg_temp;
-+		duk_int_t pc_jump1;
-+		duk_int_t pc_jump2;
-+
-+		reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+		duk__ivalue_toforcedreg(comp_ctx, left, reg_temp);
-+		duk__emit_if_true_skip(comp_ctx, reg_temp);
-+		pc_jump1 = duk__emit_jump_empty(comp_ctx);  /* jump to false */
-+		duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);  /* AssignmentExpression */
-+		duk__advance_expect(comp_ctx, DUK_TOK_COLON);
-+		pc_jump2 = duk__emit_jump_empty(comp_ctx);  /* jump to end */
-+		duk__patch_jump_here(comp_ctx, pc_jump1);
-+		duk__expr_toforcedreg(comp_ctx, res, DUK__BP_COMMA /*rbp_flags*/, reg_temp /*forced_reg*/);  /* AssignmentExpression */
-+		duk__patch_jump_here(comp_ctx, pc_jump2);
-+
-+		DUK__SETTEMP(comp_ctx, reg_temp + 1);
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_temp;
-+		return;
-+	}
-+
-+	/* ASSIGNMENT EXPRESSION */
-+
-+	case DUK_TOK_EQUALSIGN: {
-+		/*
-+		 *  Assignments are right associative, allows e.g.
-+		 *    a = 5;
-+		 *    a += b = 9;   // same as a += (b = 9)
-+		 *  -> expression value 14, a = 14, b = 9
-+		 *
-+		 *  Right associativiness is reflected in the BP for recursion,
-+		 *  "-1" ensures assignment operations are allowed.
-+		 *
-+		 *  XXX: just use DUK__BP_COMMA (i.e. no need for 2-step bp levels)?
-+		 */
-+		args = (DUK_OP_NONE << 8) + DUK__BP_ASSIGNMENT - 1;   /* DUK_OP_NONE marks a 'plain' assignment */
-+		goto assign;
-+	}
-+	case DUK_TOK_ADD_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_ADD << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_SUB_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_SUB << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_MUL_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_MUL << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_DIV_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_DIV << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_MOD_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_MOD << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_ALSHIFT_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_BASL << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_ARSHIFT_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_BASR << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_RSHIFT_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_BLSR << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_BAND_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_BAND << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_BOR_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_BOR << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+	case DUK_TOK_BXOR_EQ: {
-+		/* right associative */
-+		args = (DUK_OP_BXOR << 8) + DUK__BP_ASSIGNMENT - 1;
-+		goto assign;
-+	}
-+
-+	/* COMMA */
-+
-+	case DUK_TOK_COMMA: {
-+		/* right associative */
-+
-+		duk__ivalue_toplain_ignore(comp_ctx, left);  /* need side effects, not value */
-+		duk__expr_toplain(comp_ctx, res, DUK__BP_COMMA - 1 /*rbp_flags*/);
-+
-+		/* return 'res' (of right part) as our result */
-+		return;
-+	}
-+
-+	default: {
-+		break;
-+	}
-+	}
-+
-+	DUK_D(DUK_DPRINT("parse error: unexpected token: %ld", (long) tok));
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_PARSE_ERROR);
-+	return;
-+
-+#if 0
-+	/* XXX: shared handling for 'duk__expr_lhs'? */
-+	if (comp_ctx->curr_func.paren_level == 0 && XXX) {
-+		comp_ctx->curr_func.duk__expr_lhs = 0;
-+	}
-+#endif
-+
-+ binary:
-+	/*
-+	 *  Shared handling of binary operations
-+	 *
-+	 *  args = (is_extraop << 16) + (opcode << 8) + rbp
-+	 */
-+	{
-+		duk__ivalue_toplain(comp_ctx, left);
-+		duk__expr_toplain(comp_ctx, res, args & 0xff /*rbp_flags*/);
-+
-+		/* combine left->x1 and res->x1 (right->x1, really) -> (left->x1 OP res->x1) */
-+		DUK_ASSERT(left->t == DUK_IVAL_PLAIN);
-+		DUK_ASSERT(res->t == DUK_IVAL_PLAIN);
-+
-+		res->t = (args >> 16) ? DUK_IVAL_ARITH_EXTRAOP : DUK_IVAL_ARITH;
-+		res->op = (args >> 8) & 0xff;
-+
-+		res->x2.t = res->x1.t;
-+		res->x2.regconst = res->x1.regconst;
-+		duk_copy(ctx, res->x1.valstack_idx, res->x2.valstack_idx);
-+
-+		res->x1.t = left->x1.t;
-+		res->x1.regconst = left->x1.regconst;
-+		duk_copy(ctx, left->x1.valstack_idx, res->x1.valstack_idx);
-+
-+		DUK_DDD(DUK_DDDPRINT("binary op, res: t=%ld, x1.t=%ld, x1.regconst=0x%08lx, x2.t=%ld, x2.regconst=0x%08lx",
-+		                     (long) res->t, (long) res->x1.t, (unsigned long) res->x1.regconst, (long) res->x2.t, (unsigned long) res->x2.regconst));
-+		return;
-+	}
-+
-+ binary_logical:
-+	/*
-+	 *  Shared handling for logical AND and logical OR.
-+	 *
-+	 *  args = (truthval << 8) + rbp
-+	 *
-+	 *  Truthval determines when to skip right-hand-side.
-+	 *  For logical AND truthval=1, for logical OR truthval=0.
-+	 *
-+	 *  See doc/compiler.txt for discussion on compiling logical
-+	 *  AND and OR expressions.  The approach here is very simplistic,
-+	 *  generating extra jumps and multiple evaluations of truth values,
-+	 *  but generates code on-the-fly with only local back-patching.
-+	 *
-+	 *  Both logical AND and OR are syntactically left-associated.
-+	 *  However, logical ANDs are compiled as right associative
-+	 *  expressions, i.e. "A && B && C" as "A && (B && C)", to allow
-+	 *  skip jumps to skip over the entire tail.  Similarly for logical OR.
-+	 */
-+
-+	{
-+		duk_reg_t reg_temp;
-+		duk_int_t pc_jump;
-+		duk_small_uint_t args_truthval = args >> 8;
-+		duk_small_uint_t args_rbp = args & 0xff;
-+
-+		/* XXX: unoptimal use of temps, resetting */
-+
-+		reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+
-+		duk__ivalue_toforcedreg(comp_ctx, left, reg_temp);
-+		duk__emit_a_b(comp_ctx,
-+		              DUK_OP_IF | DUK__EMIT_FLAG_NO_SHUFFLE_A,
-+		              (duk_regconst_t) args_truthval,
-+		              (duk_regconst_t) reg_temp);  /* skip jump conditionally */
-+		pc_jump = duk__emit_jump_empty(comp_ctx);
-+		duk__expr_toforcedreg(comp_ctx, res, args_rbp /*rbp_flags*/, reg_temp /*forced_reg*/);
-+		duk__patch_jump_here(comp_ctx, pc_jump);
-+
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_temp;
-+		return;
-+	}
-+
-+ assign:
-+	/*
-+	 *  Shared assignment expression handling
-+	 *
-+	 *  args = (opcode << 8) + rbp
-+	 *
-+	 *  If 'opcode' is DUK_OP_NONE, plain assignment without arithmetic.
-+	 *  Syntactically valid left-hand-side forms which are not accepted as
-+	 *  left-hand-side values (e.g. as in "f() = 1") must NOT cause a
-+	 *  SyntaxError, but rather a run-time ReferenceError.
-+	 */
-+
-+	{
-+		duk_small_uint_t args_op = args >> 8;
-+		duk_small_uint_t args_rbp = args & 0xff;
-+
-+		/* XXX: here we need to know if 'left' is left-hand-side compatible.
-+		 * That information is no longer available from current expr parsing
-+		 * state; it would need to be carried into the 'left' ivalue or by
-+		 * some other means.
-+		 */
-+
-+		if (left->t == DUK_IVAL_VAR) {
-+			duk_hstring *h_varname;
-+			duk_reg_t reg_varbind;
-+			duk_regconst_t rc_varname;
-+			duk_regconst_t rc_res;
-+			duk_reg_t reg_temp;
-+
-+			/* already in fluly evaluated form */
-+			DUK_ASSERT(left->x1.t == DUK_ISPEC_VALUE);
-+
-+			duk__expr_toreg(comp_ctx, res, args_rbp /*rbp_flags*/);
-+			DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
-+
-+			h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
-+			DUK_ASSERT(h_varname != NULL);
-+
-+			/* E5 Section 11.13.1 (and others for other assignments), step 4 */
-+			if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
-+				goto syntax_error_lvalue;
-+			}
-+
-+			duk_dup(ctx, left->x1.valstack_idx);
-+			(void) duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname);
-+
-+			DUK_DDD(DUK_DDDPRINT("assign to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
-+			                     (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
-+
-+			if (args_op == DUK_OP_NONE) {
-+				rc_res = res->x1.regconst;
-+			} else {
-+				reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+				if (reg_varbind >= 0) {
-+					duk__emit_a_b_c(comp_ctx,
-+					                args_op,
-+					                (duk_regconst_t) reg_temp,
-+					                (duk_regconst_t) reg_varbind,
-+					                res->x1.regconst);
-+				} else {
-+					duk__emit_a_bc(comp_ctx,
-+					               DUK_OP_GETVAR,
-+					               (duk_regconst_t) reg_temp,
-+					               rc_varname);
-+					duk__emit_a_b_c(comp_ctx,
-+					                args_op,
-+					                (duk_regconst_t) reg_temp,
-+					                (duk_regconst_t) reg_temp,
-+					                res->x1.regconst);
-+				}
-+				rc_res = (duk_regconst_t) reg_temp;
-+			}
-+
-+			if (reg_varbind >= 0) {
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_LDREG,
-+				               (duk_regconst_t) reg_varbind,
-+				               rc_res);
-+			} else {
-+				/* Only a reg fits into 'A' and reg_res may be a const in
-+				 * straight assignment.
-+				 *
-+				 * XXX: here the current A/B/C split is suboptimal: we could
-+				 * just use 9 bits for reg_res (and support constants) and 17
-+				 * instead of 18 bits for the varname const index.
-+				 */
-+				if (DUK__ISCONST(comp_ctx, rc_res)) {
-+					reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+					duk__emit_a_bc(comp_ctx,
-+					               DUK_OP_LDCONST,
-+					               (duk_regconst_t) reg_temp,
-+					               rc_res);
-+					rc_res = (duk_regconst_t) reg_temp;
-+				}
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
-+				               rc_res,
-+				               rc_varname);
-+			}
-+
-+			res->t = DUK_IVAL_PLAIN;
-+			res->x1.t = DUK_ISPEC_REGCONST;
-+			res->x1.regconst = rc_res;
-+		} else if (left->t == DUK_IVAL_PROP) {
-+			/* E5 Section 11.13.1 (and others) step 4 never matches for prop writes -> no check */
-+			duk_reg_t reg_obj;
-+			duk_regconst_t rc_key;
-+			duk_regconst_t rc_res;
-+			duk_reg_t reg_temp;
-+
-+			/* Property access expressions ('a[b]') are critical to correct
-+			 * LHS evaluation ordering, see test-dev-assign-eval-order*.js.
-+			 * We must make sure that the LHS target slot (base object and
-+			 * key) don't change during RHS evaluation.  The only concrete
-+			 * problem is a register reference to a variable-bound register
-+			 * (i.e., non-temp).  Require temp regs for both key and base.
-+			 *
-+			 * Don't allow a constant for the object (even for a number
-+			 * etc), as it goes into the 'A' field of the opcode.
-+			 */
-+
-+			reg_obj = duk__ispec_toregconst_raw(comp_ctx,
-+			                                    &left->x1,
-+			                                    -1 /*forced_reg*/,
-+			                                    DUK__IVAL_FLAG_REQUIRE_TEMP /*flags*/);
-+
-+			rc_key = duk__ispec_toregconst_raw(comp_ctx,
-+			                                   &left->x2,
-+			                                   -1 /*forced_reg*/,
-+			                                   DUK__IVAL_FLAG_REQUIRE_TEMP | DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
-+
-+			/* Evaluate RHS only when LHS is safe. */
-+			duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
-+			DUK_ASSERT(res->t == DUK_IVAL_PLAIN && res->x1.t == DUK_ISPEC_REGCONST);
-+
-+			if (args_op == DUK_OP_NONE) {
-+				rc_res = res->x1.regconst;
-+			} else {
-+				reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+				duk__emit_a_b_c(comp_ctx,
-+				                DUK_OP_GETPROP,
-+				                (duk_regconst_t) reg_temp,
-+				                (duk_regconst_t) reg_obj,
-+				                rc_key);
-+				duk__emit_a_b_c(comp_ctx,
-+				                args_op,
-+				                (duk_regconst_t) reg_temp,
-+				                (duk_regconst_t) reg_temp,
-+				                res->x1.regconst);
-+				rc_res = (duk_regconst_t) reg_temp;
-+			}
-+
-+			duk__emit_a_b_c(comp_ctx,
-+			                DUK_OP_PUTPROP | DUK__EMIT_FLAG_A_IS_SOURCE,
-+			                (duk_regconst_t) reg_obj,
-+			                rc_key,
-+			                rc_res);
-+
-+			res->t = DUK_IVAL_PLAIN;
-+			res->x1.t = DUK_ISPEC_REGCONST;
-+			res->x1.regconst = rc_res;
-+		} else {
-+			/* No support for lvalues returned from new or function call expressions.
-+			 * However, these must NOT cause compile-time SyntaxErrors, but run-time
-+			 * ReferenceErrors.  Both left and right sides of the assignment must be
-+			 * evaluated before throwing a ReferenceError.  For instance:
-+			 *
-+			 *     f() = g();
-+			 *
-+			 * must result in f() being evaluated, then g() being evaluated, and
-+			 * finally, a ReferenceError being thrown.  See E5 Section 11.13.1.
-+			 */
-+
-+			duk_regconst_t rc_res;
-+
-+			/* first evaluate LHS fully to ensure all side effects are out */
-+			duk__ivalue_toplain_ignore(comp_ctx, left);
-+
-+			/* then evaluate RHS fully (its value becomes the expression value too) */
-+			rc_res = duk__expr_toregconst(comp_ctx, res, args_rbp /*rbp_flags*/);
-+
-+			duk__emit_extraop_only(comp_ctx,
-+			                       DUK_EXTRAOP_INVLHS);
-+
-+			/* XXX: this value is irrelevant because of INVLHS? */
-+
-+			res->t = DUK_IVAL_PLAIN;
-+			res->x1.t = DUK_ISPEC_REGCONST;
-+			res->x1.regconst = rc_res;
-+		}
-+
-+		return;
-+	}
-+
-+ postincdec:
-+	{
-+		/*
-+		 *  Post-increment/decrement will return the original value as its
-+		 *  result value.  However, even that value will be coerced using
-+		 *  ToNumber() which is quite awkward.  Specific bytecode opcodes
-+		 *  are used to handle these semantics.
-+		 *
-+		 *  Note that post increment/decrement has a "no LineTerminator here"
-+		 *  restriction.  This is handled by duk__expr_lbp(), which forcibly terminates
-+		 *  the previous expression if a LineTerminator occurs before '++'/'--'.
-+		 */
-+
-+		duk_reg_t reg_res;
-+		duk_small_uint_t args_op = args >> 8;
-+
-+		/* Specific assumptions for opcode numbering. */
-+		DUK_ASSERT(DUK_OP_POSTINCR + 4 == DUK_OP_POSTINCV);
-+		DUK_ASSERT(DUK_OP_POSTDECR + 4 == DUK_OP_POSTDECV);
-+		DUK_ASSERT(DUK_OP_POSTINCR + 8 == DUK_OP_POSTINCP);
-+		DUK_ASSERT(DUK_OP_POSTDECR + 8 == DUK_OP_POSTDECP);
-+
-+		reg_res = DUK__ALLOCTEMP(comp_ctx);
-+
-+		if (left->t == DUK_IVAL_VAR) {
-+			duk_hstring *h_varname;
-+			duk_reg_t reg_varbind;
-+			duk_regconst_t rc_varname;
-+
-+			h_varname = duk_get_hstring(ctx, left->x1.valstack_idx);
-+			DUK_ASSERT(h_varname != NULL);
-+
-+			if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
-+				goto syntax_error;
-+			}
-+
-+			duk_dup(ctx, left->x1.valstack_idx);
-+			if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
-+				duk__emit_a_bc(comp_ctx,
-+				               args_op,  /* e.g. DUK_OP_POSTINCR */
-+				               (duk_regconst_t) reg_res,
-+				               (duk_regconst_t) reg_varbind);
-+			} else {
-+				duk__emit_a_bc(comp_ctx,
-+				               args_op + 4,  /* e.g. DUK_OP_POSTINCV */
-+				               (duk_regconst_t) reg_res,
-+				               rc_varname);
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("postincdec to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
-+			                     (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
-+		} else if (left->t == DUK_IVAL_PROP) {
-+			duk_reg_t reg_obj;  /* allocate to reg only (not const) */
-+			duk_regconst_t rc_key;
-+
-+			reg_obj = duk__ispec_toregconst_raw(comp_ctx, &left->x1, -1 /*forced_reg*/, 0 /*flags*/);  /* don't allow const */
-+			rc_key = duk__ispec_toregconst_raw(comp_ctx, &left->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
-+			duk__emit_a_b_c(comp_ctx,
-+			                args_op + 8,  /* e.g. DUK_OP_POSTINCP */
-+			                (duk_regconst_t) reg_res,
-+			                (duk_regconst_t) reg_obj,
-+			                rc_key);
-+		} else {
-+			/* Technically return value is not needed because INVLHS will
-+			 * unconditially throw a ReferenceError.  Coercion is necessary
-+			 * for proper semantics (consider ToNumber() called for an object).
-+			 * Use DUK_EXTRAOP_UNP with a dummy register to get ToNumber().
-+			 */
-+			duk__ivalue_toforcedreg(comp_ctx, left, reg_res);
-+			duk__emit_extraop_bc(comp_ctx,
-+			                     DUK_EXTRAOP_UNP,
-+			                     reg_res);  /* for side effects, result ignored */
-+			duk__emit_extraop_only(comp_ctx,
-+			                       DUK_EXTRAOP_INVLHS);
-+		}
-+
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_REGCONST;
-+		res->x1.regconst = (duk_regconst_t) reg_res;
-+		DUK__SETTEMP(comp_ctx, reg_res + 1);
-+		return;
-+	}
-+
-+ syntax_error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_EXPRESSION);
-+	return;
-+
-+ syntax_error_lvalue:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_LVALUE);
-+	return;
-+}
-+
-+DUK_LOCAL duk_small_uint_t duk__expr_lbp(duk_compiler_ctx *comp_ctx) {
-+	duk_small_int_t tok = comp_ctx->curr_token.t;
-+
-+	DUK_ASSERT(tok >= DUK_TOK_MINVAL && tok <= DUK_TOK_MAXVAL);
-+	DUK_ASSERT(sizeof(duk__token_lbp) == DUK_TOK_MAXVAL + 1);
-+
-+	/* XXX: integrate support for this into led() instead?
-+	 * Similar issue as post-increment/post-decrement.
-+	 */
-+
-+	/* prevent duk__expr_led() by using a binding power less than anything valid */
-+	if (tok == DUK_TOK_IN && !comp_ctx->curr_func.allow_in) {
-+		return 0;
-+	}
-+
-+	if ((tok == DUK_TOK_DECREMENT || tok == DUK_TOK_INCREMENT) &&
-+	    (comp_ctx->curr_token.lineterm)) {
-+		/* '++' or '--' in a post-increment/decrement position,
-+		 * and a LineTerminator occurs between the operator and
-+		 * the preceding expression.  Force the previous expr
-+		 * to terminate, in effect treating e.g. "a,b\n++" as
-+		 * "a,b;++" (= SyntaxError).
-+		 */
-+		return 0;
-+	}
-+
-+	return DUK__TOKEN_LBP_GET_BP(duk__token_lbp[tok]);  /* format is bit packed */
-+}
-+
-+/*
-+ *  Expression parsing.
-+ *
-+ *  Upon entry to 'expr' and its variants, 'curr_tok' is assumed to be the
-+ *  first token of the expression.  Upon exit, 'curr_tok' will be the first
-+ *  token not part of the expression (e.g. semicolon terminating an expression
-+ *  statement).
-+ */
-+
-+#define DUK__EXPR_RBP_MASK           0xff
-+#define DUK__EXPR_FLAG_REJECT_IN     (1 << 8)
-+#define DUK__EXPR_FLAG_ALLOW_EMPTY   (1 << 9)
-+
-+/* main expression parser function */
-+DUK_LOCAL void duk__expr(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_ivalue tmp_alloc;   /* 'res' is used for "left", and 'tmp' for "right" */
-+	duk_ivalue *tmp = &tmp_alloc;
-+	duk_small_uint_t rbp;
-+
-+	DUK__RECURSION_INCREASE(comp_ctx, thr);
-+
-+	duk_require_stack(ctx, DUK__PARSE_EXPR_SLOTS);
-+
-+	/* filter out flags from exprtop rbp_flags here to save space */
-+	rbp = rbp_flags & DUK__EXPR_RBP_MASK;
-+
-+	DUK_DDD(DUK_DDDPRINT("duk__expr(), rbp_flags=%ld, rbp=%ld, allow_in=%ld, paren_level=%ld",
-+	                     (long) rbp_flags, (long) rbp, (long) comp_ctx->curr_func.allow_in,
-+	                     (long) comp_ctx->curr_func.paren_level));
-+
-+	DUK_MEMZERO(&tmp_alloc, sizeof(tmp_alloc));
-+	tmp->x1.valstack_idx = duk_get_top(ctx);
-+	tmp->x2.valstack_idx = tmp->x1.valstack_idx + 1;
-+	duk_push_undefined(ctx);
-+	duk_push_undefined(ctx);
-+
-+	/* XXX: where to release temp regs in intermediate expressions?
-+	 * e.g. 1+2+3 -> don't inflate temp register count when parsing this.
-+	 * that particular expression temp regs can be forced here.
-+	 */
-+
-+	/* XXX: increase ctx->expr_tokens here for every consumed token
-+	 * (this would be a nice statistic)?
-+	 */
-+
-+	if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON || comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
-+		/* XXX: possibly incorrect handling of empty expression */
-+		DUK_DDD(DUK_DDDPRINT("empty expression"));
-+		if (!(rbp_flags & DUK__EXPR_FLAG_ALLOW_EMPTY)) {
-+			DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_EMPTY_EXPR_NOT_ALLOWED);
-+		}
-+		res->t = DUK_IVAL_PLAIN;
-+		res->x1.t = DUK_ISPEC_VALUE;
-+		duk_push_undefined(ctx);
-+		duk_replace(ctx, res->x1.valstack_idx);
-+		goto cleanup;
-+	}
-+
-+	duk__advance(comp_ctx);
-+	duk__expr_nud(comp_ctx, res);  /* reuse 'res' as 'left' */
-+	while (rbp < duk__expr_lbp(comp_ctx)) {
-+		duk__advance(comp_ctx);
-+		duk__expr_led(comp_ctx, res, tmp);
-+		duk__copy_ivalue(comp_ctx, tmp, res);  /* tmp -> res */
-+	}
-+
-+ cleanup:
-+	/* final result is already in 'res' */
-+
-+	duk_pop_2(ctx);
-+
-+	DUK__RECURSION_DECREASE(comp_ctx, thr);
-+}
-+
-+DUK_LOCAL void duk__exprtop(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk_hthread *thr = comp_ctx->thr;
-+
-+	/* Note: these variables must reside in 'curr_func' instead of the global
-+	 * context: when parsing function expressions, expression parsing is nested.
-+	 */
-+	comp_ctx->curr_func.nud_count = 0;
-+	comp_ctx->curr_func.led_count = 0;
-+	comp_ctx->curr_func.paren_level = 0;
-+	comp_ctx->curr_func.expr_lhs = 1;
-+	comp_ctx->curr_func.allow_in = (rbp_flags & DUK__EXPR_FLAG_REJECT_IN ? 0 : 1);
-+
-+	duk__expr(comp_ctx, res, rbp_flags);
-+
-+	if (!(rbp_flags & DUK__EXPR_FLAG_ALLOW_EMPTY) && duk__expr_is_empty(comp_ctx)) {
-+		DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_EMPTY_EXPR_NOT_ALLOWED);
-+	}
-+}
-+
-+/* A bunch of helpers (for size optimization) that combine duk__expr()/duk__exprtop()
-+ * and result conversions.
-+ *
-+ * Each helper needs at least 2-3 calls to make it worth while to wrap.
-+ */
-+
-+DUK_LOCAL duk_reg_t duk__expr_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk__expr(comp_ctx, res, rbp_flags);
-+	return duk__ivalue_toreg(comp_ctx, res);
-+}
-+
-+#if 0  /* unused */
-+DUK_LOCAL duk_reg_t duk__expr_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk__expr(comp_ctx, res, rbp_flags);
-+	return duk__ivalue_totempreg(comp_ctx, res);
-+}
-+#endif
-+
-+DUK_LOCAL void duk__expr_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg) {
-+	DUK_ASSERT(forced_reg >= 0);
-+	duk__expr(comp_ctx, res, rbp_flags);
-+	duk__ivalue_toforcedreg(comp_ctx, res, forced_reg);
-+}
-+
-+DUK_LOCAL duk_regconst_t duk__expr_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk__expr(comp_ctx, res, rbp_flags);
-+	return duk__ivalue_toregconst(comp_ctx, res);
-+}
-+
-+DUK_LOCAL void duk__expr_toplain(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk__expr(comp_ctx, res, rbp_flags);
-+	duk__ivalue_toplain(comp_ctx, res);
-+}
-+
-+DUK_LOCAL void duk__expr_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk__expr(comp_ctx, res, rbp_flags);
-+	duk__ivalue_toplain_ignore(comp_ctx, res);
-+}
-+
-+DUK_LOCAL duk_reg_t duk__exprtop_toreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk__exprtop(comp_ctx, res, rbp_flags);
-+	return duk__ivalue_toreg(comp_ctx, res);
-+}
-+
-+#if 0  /* unused */
-+DUK_LOCAL duk_reg_t duk__exprtop_totempreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk__exprtop(comp_ctx, res, rbp_flags);
-+	return duk__ivalue_totempreg(comp_ctx, res);
-+}
-+#endif
-+
-+#if 0  /* unused */
-+DUK_LOCAL void duk__exprtop_toforcedreg(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags, duk_reg_t forced_reg) {
-+	DUK_ASSERT(forced_reg >= 0);
-+	duk__exprtop(comp_ctx, res, rbp_flags);
-+	duk__ivalue_toforcedreg(comp_ctx, res, forced_reg);
-+}
-+#endif
-+
-+DUK_LOCAL duk_regconst_t duk__exprtop_toregconst(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t rbp_flags) {
-+	duk__exprtop(comp_ctx, res, rbp_flags);
-+	return duk__ivalue_toregconst(comp_ctx, res);
-+}
-+
-+#if 0  /* unused */
-+DUK_LOCAL void duk__exprtop_toplain_ignore(duk_compiler_ctx *comp_ctx, duk_ivalue *res, int rbp_flags) {
-+	duk__exprtop(comp_ctx, res, rbp_flags);
-+	duk__ivalue_toplain_ignore(comp_ctx, res);
-+}
-+#endif
-+
-+/*
-+ *  Parse an individual source element (top level statement) or a statement.
-+ *
-+ *  Handles labeled statements automatically (peeling away labels before
-+ *  parsing an expression that follows the label(s)).
-+ *
-+ *  Upon entry, 'curr_tok' contains the first token of the statement (parsed
-+ *  in "allow regexp literal" mode).  Upon exit, 'curr_tok' contains the first
-+ *  token following the statement (if the statement has a terminator, this is
-+ *  the token after the terminator).
-+ */
-+
-+#ifdef DUK__HAS_VAL
-+#undef DUK__HAS_VAL
-+#endif
-+#ifdef DUK__HAS_TERM
-+#undef DUK__HAS_TERM
-+#endif
-+#ifdef DUK__ALLOW_AUTO_SEMI_ALWAYS
-+#undef DUK__ALLOW_AUTO_SEMI_ALWAYS
-+#endif
-+#ifdef DUK__STILL_PROLOGUE
-+#undef DUK__STILL_PROLOGUE
-+#endif
-+#ifdef DUK__IS_TERMINAL
-+#undef DUK__IS_TERMINAL
-+#endif
-+
-+#define DUK__HAS_VAL                  (1 << 0)  /* stmt has non-empty value */
-+#define DUK__HAS_TERM                 (1 << 1)  /* stmt has explicit/implicit semicolon terminator */
-+#define DUK__ALLOW_AUTO_SEMI_ALWAYS   (1 << 2)  /* allow automatic semicolon even without lineterm (compatibility) */
-+#define DUK__STILL_PROLOGUE           (1 << 3)  /* statement does not terminate directive prologue */
-+#define DUK__IS_TERMINAL              (1 << 4)  /* statement is guaranteed to be terminal (control doesn't flow to next statement) */
-+
-+/* Parse a single variable declaration (e.g. "i" or "i=10").  A leading 'var'
-+ * has already been eaten.  These is no return value in 'res', it is used only
-+ * as a temporary.
-+ *
-+ * When called from 'for-in' statement parser, the initializer expression must
-+ * not allow the 'in' token.  The caller supply additional expression parsing
-+ * flags (like DUK__EXPR_FLAG_REJECT_IN) in 'expr_flags'.
-+ *
-+ * Finally, out_rc_varname and out_reg_varbind are updated to reflect where
-+ * the identifier is bound:
-+ *
-+ *    If register bound:      out_reg_varbind >= 0, out_rc_varname == 0 (ignore)
-+ *    If not register bound:  out_reg_varbind < 0, out_rc_varname >= 0
-+ *
-+ * These allow the caller to use the variable for further assignment, e.g.
-+ * as is done in 'for-in' parsing.
-+ */
-+
-+DUK_LOCAL void duk__parse_var_decl(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_small_uint_t expr_flags, duk_reg_t *out_reg_varbind, duk_regconst_t *out_rc_varname) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *h_varname;
-+	duk_reg_t reg_varbind;
-+	duk_regconst_t rc_varname;
-+
-+	/* assume 'var' has been eaten */
-+
-+	/* Note: Identifier rejects reserved words */
-+	if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) {
-+		goto syntax_error;
-+	}
-+	h_varname = comp_ctx->curr_token.str1;
-+
-+	DUK_ASSERT(h_varname != NULL);
-+
-+	/* strict mode restrictions (E5 Section 12.2.1) */
-+	if (duk__hstring_is_eval_or_arguments_in_strict_mode(comp_ctx, h_varname)) {
-+		goto syntax_error;
-+	}
-+
-+	/* register declarations in first pass */
-+	if (comp_ctx->curr_func.in_scanning) {
-+		duk_uarridx_t n;
-+		DUK_DDD(DUK_DDDPRINT("register variable declaration %!O in pass 1",
-+		                     (duk_heaphdr *) h_varname));
-+		n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
-+		duk_push_hstring(ctx, h_varname);
-+		duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n);
-+		duk_push_int(ctx, DUK_DECL_TYPE_VAR + (0 << 8));
-+		duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n + 1);
-+	}
-+
-+	duk_push_hstring(ctx, h_varname);  /* push before advancing to keep reachable */
-+
-+	/* register binding lookup is based on varmap (even in first pass) */
-+	duk_dup_top(ctx);
-+	(void) duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname);
-+
-+	duk__advance(comp_ctx);  /* eat identifier */
-+
-+	if (comp_ctx->curr_token.t == DUK_TOK_EQUALSIGN) {
-+		duk__advance(comp_ctx);
-+
-+		DUK_DDD(DUK_DDDPRINT("vardecl, assign to '%!O' -> reg_varbind=%ld, rc_varname=%ld",
-+		                     (duk_heaphdr *) h_varname, (long) reg_varbind, (long) rc_varname));
-+
-+		duk__exprtop(comp_ctx, res, DUK__BP_COMMA | expr_flags /*rbp_flags*/);  /* AssignmentExpression */
-+
-+		if (reg_varbind >= 0) {
-+			duk__ivalue_toforcedreg(comp_ctx, res, reg_varbind);
-+		} else {
-+			duk_reg_t reg_val;
-+			reg_val = duk__ivalue_toreg(comp_ctx, res);
-+			duk__emit_a_bc(comp_ctx,
-+			               DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
-+			               (duk_regconst_t) reg_val,
-+			               rc_varname);
-+		}
-+	}
-+
-+	duk_pop(ctx);  /* pop varname */
-+
-+	*out_rc_varname = rc_varname;
-+	*out_reg_varbind = reg_varbind;
-+
-+	return;
-+
-+ syntax_error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_VAR_DECLARATION);
-+}
-+
-+DUK_LOCAL void duk__parse_var_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_reg_t reg_varbind;
-+	duk_regconst_t rc_varname;
-+
-+	duk__advance(comp_ctx);  /* eat 'var' */
-+
-+	for (;;) {
-+		/* rc_varname and reg_varbind are ignored here */
-+		duk__parse_var_decl(comp_ctx, res, 0, &reg_varbind, &rc_varname);
-+
-+		if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
-+			break;
-+		}
-+		duk__advance(comp_ctx);
-+	}
-+}
-+
-+DUK_LOCAL void duk__parse_for_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_int_t pc_v34_lhs;    /* start variant 3/4 left-hand-side code (L1 in doc/compiler.txt example) */
-+	duk_reg_t temp_reset;    /* knock back "next temp" to this whenever possible */
-+	duk_reg_t reg_temps;     /* preallocated temporaries (2) for variants 3 and 4 */
-+
-+	DUK_DDD(DUK_DDDPRINT("start parsing a for/for-in statement"));
-+
-+	/* Two temporaries are preallocated here for variants 3 and 4 which need
-+	 * registers which are never clobbered by expressions in the loop
-+	 * (concretely: for the enumerator object and the next enumerated value).
-+	 * Variants 1 and 2 "release" these temps.
-+	 */
-+
-+	reg_temps = DUK__ALLOCTEMPS(comp_ctx, 2);
-+
-+	temp_reset = DUK__GETTEMP(comp_ctx);
-+
-+	/*
-+	 *  For/for-in main variants are:
-+	 *
-+	 *    1. for (ExpressionNoIn_opt; Expression_opt; Expression_opt) Statement
-+	 *    2. for (var VariableDeclarationNoIn; Expression_opt; Expression_opt) Statement
-+	 *    3. for (LeftHandSideExpression in Expression) Statement
-+	 *    4. for (var VariableDeclarationNoIn in Expression) Statement
-+	 *
-+	 *  Parsing these without arbitrary lookahead or backtracking is relatively
-+	 *  tricky but we manage to do so for now.
-+	 *
-+	 *  See doc/compiler.txt for a detailed discussion of control flow
-+	 *  issues, evaluation order issues, etc.
-+	 */
-+
-+	duk__advance(comp_ctx);  /* eat 'for' */
-+	duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
-+
-+	DUK_DDD(DUK_DDDPRINT("detecting for/for-in loop variant, pc=%ld", (long) duk__get_current_pc(comp_ctx)));
-+
-+	/* a label site has been emitted by duk__parse_stmt() automatically
-+	 * (it will also emit the ENDLABEL).
-+	 */
-+
-+	if (comp_ctx->curr_token.t == DUK_TOK_VAR) {
-+		/*
-+		 *  Variant 2 or 4
-+		 */
-+
-+		duk_reg_t reg_varbind;       /* variable binding register if register-bound (otherwise < 0) */
-+		duk_regconst_t rc_varname;   /* variable name reg/const, if variable not register-bound */
-+
-+		duk__advance(comp_ctx);  /* eat 'var' */
-+		duk__parse_var_decl(comp_ctx, res, DUK__EXPR_FLAG_REJECT_IN, &reg_varbind, &rc_varname);
-+		DUK__SETTEMP(comp_ctx, temp_reset);
-+
-+		if (comp_ctx->curr_token.t == DUK_TOK_IN) {
-+			/*
-+			 *  Variant 4
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("detected for variant 4: for (var VariableDeclarationNoIn in Expression) Statement"));
-+			pc_v34_lhs = duk__get_current_pc(comp_ctx);  /* jump is inserted here */
-+			if (reg_varbind >= 0) {
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_LDREG,
-+				               (duk_regconst_t) reg_varbind,
-+				               (duk_regconst_t) (reg_temps + 0));
-+			} else {
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
-+				               (duk_regconst_t) (reg_temps + 0),
-+				               rc_varname);
-+			}
-+			goto parse_3_or_4;
-+		} else {
-+			/*
-+			 *  Variant 2
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("detected for variant 2: for (var VariableDeclarationNoIn; Expression_opt; Expression_opt) Statement"));
-+			for (;;) {
-+				/* more initializers */
-+				if (comp_ctx->curr_token.t != DUK_TOK_COMMA) {
-+					break;
-+				}
-+				DUK_DDD(DUK_DDDPRINT("variant 2 has another variable initializer"));
-+
-+				duk__advance(comp_ctx);  /* eat comma */
-+				duk__parse_var_decl(comp_ctx, res, DUK__EXPR_FLAG_REJECT_IN, &reg_varbind, &rc_varname);
-+			}
-+			goto parse_1_or_2;
-+		}
-+	} else {
-+		/*
-+		 *  Variant 1 or 3
-+		 */
-+
-+		pc_v34_lhs = duk__get_current_pc(comp_ctx);  /* jump is inserted here (variant 3) */
-+
-+		/* Note that duk__exprtop() here can clobber any reg above current temp_next,
-+		 * so any loop variables (e.g. enumerator) must be "preallocated".
-+		 */
-+
-+		/* don't coerce yet to a plain value (variant 3 needs special handling) */
-+		duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_REJECT_IN | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/);  /* Expression */
-+		if (comp_ctx->curr_token.t == DUK_TOK_IN) {
-+			/*
-+			 *  Variant 3
-+			 */
-+
-+			/* XXX: need to determine LHS type, and check that it is LHS compatible */
-+			DUK_DDD(DUK_DDDPRINT("detected for variant 3: for (LeftHandSideExpression in Expression) Statement"));
-+			if (duk__expr_is_empty(comp_ctx)) {
-+				goto syntax_error;  /* LeftHandSideExpression does not allow empty expression */
-+			}
-+
-+			if (res->t == DUK_IVAL_VAR) {
-+				duk_reg_t reg_varbind;
-+				duk_regconst_t rc_varname;
-+
-+				duk_dup(ctx, res->x1.valstack_idx);
-+				if (duk__lookup_lhs(comp_ctx, &reg_varbind, &rc_varname)) {
-+					duk__emit_a_bc(comp_ctx,
-+					               DUK_OP_LDREG,
-+					               (duk_regconst_t) reg_varbind,
-+					               (duk_regconst_t) (reg_temps + 0));
-+				} else {
-+					duk__emit_a_bc(comp_ctx,
-+					               DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
-+					               (duk_regconst_t) (reg_temps + 0),
-+					               rc_varname);
-+				}
-+			} else if (res->t == DUK_IVAL_PROP) {
-+				/* Don't allow a constant for the object (even for a number etc), as
-+				 * it goes into the 'A' field of the opcode.
-+				 */
-+				duk_reg_t reg_obj;
-+				duk_regconst_t rc_key;
-+				reg_obj = duk__ispec_toregconst_raw(comp_ctx, &res->x1, -1 /*forced_reg*/, 0 /*flags*/);  /* don't allow const */
-+				rc_key = duk__ispec_toregconst_raw(comp_ctx, &res->x2, -1 /*forced_reg*/, DUK__IVAL_FLAG_ALLOW_CONST /*flags*/);
-+				duk__emit_a_b_c(comp_ctx,
-+				                DUK_OP_PUTPROP | DUK__EMIT_FLAG_A_IS_SOURCE,
-+				                (duk_regconst_t) reg_obj,
-+				                rc_key,
-+				                (duk_regconst_t) (reg_temps + 0));
-+			} else {
-+				duk__ivalue_toplain_ignore(comp_ctx, res);  /* just in case */
-+				duk__emit_extraop_only(comp_ctx,
-+				                       DUK_EXTRAOP_INVLHS);
-+			}
-+			goto parse_3_or_4;
-+		} else {
-+			/*
-+			 *  Variant 1
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("detected for variant 1: for (ExpressionNoIn_opt; Expression_opt; Expression_opt) Statement"));
-+			duk__ivalue_toplain_ignore(comp_ctx, res);
-+			goto parse_1_or_2;
-+		}
-+	}
-+
-+ parse_1_or_2:
-+	/*
-+	 *  Parse variant 1 or 2.  The first part expression (which differs
-+	 *  in the variants) has already been parsed and its code emitted.
-+	 *
-+	 *  reg_temps + 0: unused
-+	 *  reg_temps + 1: unused
-+	 */
-+	{
-+		duk_regconst_t rc_cond;
-+		duk_int_t pc_l1, pc_l2, pc_l3, pc_l4;
-+		duk_int_t pc_jumpto_l3, pc_jumpto_l4;
-+		duk_bool_t expr_c_empty;
-+
-+		DUK_DDD(DUK_DDDPRINT("shared code for parsing variants 1 and 2"));
-+
-+		/* "release" preallocated temps since we won't need them */
-+		temp_reset = reg_temps + 0;
-+		DUK__SETTEMP(comp_ctx, temp_reset);
-+
-+		duk__advance_expect(comp_ctx, DUK_TOK_SEMICOLON);
-+
-+		pc_l1 = duk__get_current_pc(comp_ctx);
-+		duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/);  /* Expression_opt */
-+		if (duk__expr_is_empty(comp_ctx)) {
-+			/* no need to coerce */
-+			pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx);  /* to body */
-+			pc_jumpto_l4 = -1;  /* omitted */
-+		} else {
-+			rc_cond = duk__ivalue_toregconst(comp_ctx, res);
-+			duk__emit_if_false_skip(comp_ctx, rc_cond);
-+			pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx);  /* to body */
-+			pc_jumpto_l4 = duk__emit_jump_empty(comp_ctx);  /* to exit */
-+		}
-+		DUK__SETTEMP(comp_ctx, temp_reset);
-+
-+		duk__advance_expect(comp_ctx, DUK_TOK_SEMICOLON);
-+
-+		pc_l2 = duk__get_current_pc(comp_ctx);
-+		duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR | DUK__EXPR_FLAG_ALLOW_EMPTY /*rbp_flags*/);  /* Expression_opt */
-+		if (duk__expr_is_empty(comp_ctx)) {
-+			/* no need to coerce */
-+			expr_c_empty = 1;
-+			/* JUMP L1 omitted */
-+		} else {
-+			duk__ivalue_toplain_ignore(comp_ctx, res);
-+			expr_c_empty = 0;
-+			duk__emit_jump(comp_ctx, pc_l1);
-+		}
-+		DUK__SETTEMP(comp_ctx, temp_reset);
-+
-+		duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+
-+		pc_l3 = duk__get_current_pc(comp_ctx);
-+		duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
-+		if (expr_c_empty) {
-+			duk__emit_jump(comp_ctx, pc_l1);
-+		} else {
-+			duk__emit_jump(comp_ctx, pc_l2);
-+		}
-+		/* temp reset is not necessary after duk__parse_stmt(), which already does it */
-+
-+		pc_l4 = duk__get_current_pc(comp_ctx);
-+
-+		DUK_DDD(DUK_DDDPRINT("patching jumps: jumpto_l3: %ld->%ld, jumpto_l4: %ld->%ld, "
-+		                     "break: %ld->%ld, continue: %ld->%ld",
-+			             (long) pc_jumpto_l3, (long) pc_l3, (long) pc_jumpto_l4, (long) pc_l4,
-+		                     (long) (pc_label_site + 1), (long) pc_l4, (long) (pc_label_site + 2), (long) pc_l2));
-+
-+		duk__patch_jump(comp_ctx, pc_jumpto_l3, pc_l3);
-+		duk__patch_jump(comp_ctx, pc_jumpto_l4, pc_l4);
-+		duk__patch_jump(comp_ctx,
-+		                pc_label_site + 1,
-+		                pc_l4);                         /* break jump */
-+		duk__patch_jump(comp_ctx,
-+		                pc_label_site + 2,
-+		                expr_c_empty ? pc_l1 : pc_l2);  /* continue jump */
-+	}
-+	goto finished;
-+
-+ parse_3_or_4:
-+	/*
-+	 *  Parse variant 3 or 4.
-+	 *
-+	 *  For variant 3 (e.g. "for (A in C) D;") the code for A (except the
-+	 *  final property/variable write) has already been emitted.  The first
-+	 *  instruction of that code is at pc_v34_lhs; a JUMP needs to be inserted
-+	 *  there to satisfy control flow needs.
-+	 *
-+	 *  For variant 4, if the variable declaration had an initializer
-+	 *  (e.g. "for (var A = B in C) D;") the code for the assignment
-+	 *  (B) has already been emitted.
-+	 *
-+	 *  Variables set before entering here:
-+	 *
-+	 *    pc_v34_lhs:    insert a "JUMP L2" here (see doc/compiler.txt example).
-+	 *    reg_temps + 0: iteration target value (written to LHS)
-+	 *    reg_temps + 1: enumerator object
-+	 */
-+	{
-+		duk_int_t pc_l1, pc_l2, pc_l3, pc_l4, pc_l5;
-+		duk_int_t pc_jumpto_l2, pc_jumpto_l3, pc_jumpto_l4, pc_jumpto_l5;
-+		duk_reg_t reg_target;
-+
-+		DUK_DDD(DUK_DDDPRINT("shared code for parsing variants 3 and 4, pc_v34_lhs=%ld", (long) pc_v34_lhs));
-+
-+		DUK__SETTEMP(comp_ctx, temp_reset);
-+
-+		/* First we need to insert a jump in the middle of previously
-+		 * emitted code to get the control flow right.  No jumps can
-+		 * cross the position where the jump is inserted.  See doc/compiler.txt
-+		 * for discussion on the intricacies of control flow and side effects
-+		 * for variants 3 and 4.
-+		 */
-+
-+		duk__insert_jump_entry(comp_ctx, pc_v34_lhs);
-+		pc_jumpto_l2 = pc_v34_lhs;  /* inserted jump */
-+		pc_l1 = pc_v34_lhs + 1;     /* +1, right after inserted jump */
-+
-+		/* The code for writing reg_temps + 0 to the left hand side has already
-+		 * been emitted.
-+		 */
-+
-+		pc_jumpto_l3 = duk__emit_jump_empty(comp_ctx);  /* -> loop body */
-+
-+		duk__advance(comp_ctx);  /* eat 'in' */
-+
-+		/* Parse enumeration target and initialize enumerator.  For 'null' and 'undefined',
-+		 * INITENUM will creates a 'null' enumerator which works like an empty enumerator
-+		 * (E5 Section 12.6.4, step 3).  Note that INITENUM requires the value to be in a
-+		 * register (constant not allowed).
-+		 */
-+
-+		pc_l2 = duk__get_current_pc(comp_ctx);
-+		reg_target = duk__exprtop_toreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);  /* Expression */
-+		duk__emit_extraop_b_c(comp_ctx,
-+		                      DUK_EXTRAOP_INITENUM | DUK__EMIT_FLAG_B_IS_TARGET,
-+		                      (duk_regconst_t) (reg_temps + 1),
-+		                      (duk_regconst_t) reg_target);
-+		pc_jumpto_l4 = duk__emit_jump_empty(comp_ctx);
-+		DUK__SETTEMP(comp_ctx, temp_reset);
-+
-+		duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+
-+		pc_l3 = duk__get_current_pc(comp_ctx);
-+		duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
-+		/* temp reset is not necessary after duk__parse_stmt(), which already does it */
-+
-+		/* NEXTENUM needs a jump slot right after the main opcode.
-+		 * We need the code emitter to reserve the slot: if there's
-+		 * target shuffling, the target shuffle opcodes must happen
-+		 * after the jump slot (for NEXTENUM the shuffle opcodes are
-+		 * not needed if the enum is finished).
-+		 */
-+		pc_l4 = duk__get_current_pc(comp_ctx);
-+		duk__emit_extraop_b_c(comp_ctx,
-+		                      DUK_EXTRAOP_NEXTENUM | DUK__EMIT_FLAG_B_IS_TARGET | DUK__EMIT_FLAG_RESERVE_JUMPSLOT,
-+		                      (duk_regconst_t) (reg_temps + 0),
-+		                      (duk_regconst_t) (reg_temps + 1));
-+		pc_jumpto_l5 = comp_ctx->emit_jumpslot_pc;  /* NEXTENUM jump slot: executed when enum finished */
-+		duk__emit_jump(comp_ctx, pc_l1);  /* jump to next loop, using reg_v34_iter as iterated value */
-+
-+		pc_l5 = duk__get_current_pc(comp_ctx);
-+
-+		/* XXX: since the enumerator may be a memory expensive object,
-+		 * perhaps clear it explicitly here?  If so, break jump must
-+		 * go through this clearing operation.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("patching jumps: jumpto_l2: %ld->%ld, jumpto_l3: %ld->%ld, "
-+		                     "jumpto_l4: %ld->%ld, jumpto_l5: %ld->%ld, "
-+		                     "break: %ld->%ld, continue: %ld->%ld",
-+			             (long) pc_jumpto_l2, (long) pc_l2, (long) pc_jumpto_l3, (long) pc_l3,
-+			             (long) pc_jumpto_l4, (long) pc_l4, (long) pc_jumpto_l5, (long) pc_l5,
-+		                     (long) (pc_label_site + 1), (long) pc_l5, (long) (pc_label_site + 2), (long) pc_l4));
-+
-+		duk__patch_jump(comp_ctx, pc_jumpto_l2, pc_l2);
-+		duk__patch_jump(comp_ctx, pc_jumpto_l3, pc_l3);
-+		duk__patch_jump(comp_ctx, pc_jumpto_l4, pc_l4);
-+		duk__patch_jump(comp_ctx, pc_jumpto_l5, pc_l5);
-+		duk__patch_jump(comp_ctx, pc_label_site + 1, pc_l5);  /* break jump */
-+		duk__patch_jump(comp_ctx, pc_label_site + 2, pc_l4);  /* continue jump */
-+	}
-+	goto finished;
-+
-+ finished:
-+	DUK_DDD(DUK_DDDPRINT("end parsing a for/for-in statement"));
-+	return;
-+
-+ syntax_error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_FOR);
-+}
-+
-+DUK_LOCAL void duk__parse_switch_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_reg_t temp_at_loop;
-+	duk_regconst_t rc_switch;    /* reg/const for switch value */
-+	duk_regconst_t rc_case;      /* reg/const for case value */
-+	duk_reg_t reg_temp;          /* general temp register */
-+	duk_int_t pc_prevcase = -1;
-+	duk_int_t pc_prevstmt = -1;
-+	duk_int_t pc_default = -1;   /* -1 == not set, -2 == pending (next statement list) */
-+
-+	/* Note: negative pc values are ignored when patching jumps, so no explicit checks needed */
-+
-+	/*
-+	 *  Switch is pretty complicated because of several conflicting concerns:
-+	 *
-+	 *    - Want to generate code without an intermediate representation,
-+	 *      i.e., in one go
-+	 *
-+	 *    - Case selectors are expressions, not values, and may thus e.g. throw
-+	 *      exceptions (which causes evaluation order concerns)
-+	 *
-+	 *    - Evaluation semantics of case selectors and default clause need to be
-+	 *      carefully implemented to provide correct behavior even with case value
-+	 *      side effects
-+	 *
-+	 *    - Fall through case and default clauses; avoiding dead JUMPs if case
-+	 *      ends with an unconditional jump (a break or a continue)
-+	 *
-+	 *    - The same case value may occur multiple times, but evaluation rules
-+	 *      only process the first match before switching to a "propagation" mode
-+	 *      where case values are no longer evaluated
-+	 *
-+	 *  See E5 Section 12.11.  Also see doc/compiler.txt for compilation
-+	 *  discussion.
-+	 */
-+
-+	duk__advance(comp_ctx);
-+	duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
-+	rc_switch = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+	duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+	duk__advance_expect(comp_ctx, DUK_TOK_LCURLY);
-+
-+	DUK_DDD(DUK_DDDPRINT("switch value in register %ld", (long) rc_switch));
-+
-+	temp_at_loop = DUK__GETTEMP(comp_ctx);
-+
-+	for (;;) {
-+		duk_int_t num_stmts;
-+		duk_small_int_t tok;
-+
-+		/* sufficient for keeping temp reg numbers in check */
-+		DUK__SETTEMP(comp_ctx, temp_at_loop);
-+
-+		if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
-+			break;
-+		}
-+
-+		/*
-+		 *  Parse a case or default clause.
-+		 */
-+
-+		if (comp_ctx->curr_token.t == DUK_TOK_CASE) {
-+			/*
-+			 *  Case clause.
-+			 *
-+			 *  Note: cannot use reg_case as a temp register (for SEQ target)
-+			 *  because it may be a constant.
-+			 */
-+
-+			duk__patch_jump_here(comp_ctx, pc_prevcase);  /* chain jumps for case
-+			                                               * evaluation and checking
-+			                                               */
-+
-+			duk__advance(comp_ctx);
-+			rc_case = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+			duk__advance_expect(comp_ctx, DUK_TOK_COLON);
-+
-+			reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+			duk__emit_a_b_c(comp_ctx,
-+			                DUK_OP_SEQ,
-+			                (duk_regconst_t) reg_temp,
-+			                rc_switch,
-+			                rc_case);
-+			duk__emit_if_true_skip(comp_ctx, (duk_regconst_t) reg_temp);
-+
-+			/* jump to next case clause */
-+			pc_prevcase = duk__emit_jump_empty(comp_ctx);  /* no match, next case */
-+
-+			/* statements go here (if any) on next loop */
-+		} else if (comp_ctx->curr_token.t == DUK_TOK_DEFAULT) {
-+			/*
-+			 *  Default clause.
-+			 */
-+
-+			if (pc_default >= 0) {
-+				goto syntax_error;
-+			}
-+			duk__advance(comp_ctx);
-+			duk__advance_expect(comp_ctx, DUK_TOK_COLON);
-+
-+			/* Fix for https://github.com/svaarala/duktape/issues/155:
-+			 * If 'default' is first clause (detected by pc_prevcase < 0)
-+			 * we need to ensure we stay in the matching chain.
-+			 */
-+			if (pc_prevcase < 0) {
-+				DUK_DD(DUK_DDPRINT("default clause is first, emit prevcase jump"));
-+				pc_prevcase = duk__emit_jump_empty(comp_ctx);
-+			}
-+
-+			/* default clause matches next statement list (if any) */
-+			pc_default = -2;
-+		} else {
-+			/* Code is not accepted before the first case/default clause */
-+			goto syntax_error;
-+		}
-+
-+		/*
-+		 *  Parse code after the clause.  Possible terminators are
-+		 *  'case', 'default', and '}'.
-+		 *
-+		 *  Note that there may be no code at all, not even an empty statement,
-+		 *  between case clauses.  This must be handled just like an empty statement
-+		 *  (omitting seemingly pointless JUMPs), to avoid situations like
-+		 *  test-bug-case-fallthrough.js.
-+		 */
-+
-+		num_stmts = 0;
-+		if (pc_default == -2) {
-+			pc_default = duk__get_current_pc(comp_ctx);
-+		}
-+
-+		/* Note: this is correct even for default clause statements:
-+		 * they participate in 'fall-through' behavior even if the
-+		 * default clause is in the middle.
-+		 */
-+		duk__patch_jump_here(comp_ctx, pc_prevstmt);  /* chain jumps for 'fall-through'
-+		                                               * after a case matches.
-+		                                               */
-+
-+		for (;;) {
-+			tok = comp_ctx->curr_token.t;
-+			if (tok == DUK_TOK_CASE || tok == DUK_TOK_DEFAULT ||
-+			    tok == DUK_TOK_RCURLY) {
-+				break;
-+			}
-+			num_stmts++;
-+			duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
-+		}
-+
-+		/* fall-through jump to next code of next case (backpatched) */
-+		pc_prevstmt = duk__emit_jump_empty(comp_ctx);
-+
-+		/* XXX: would be nice to omit this jump when the jump is not
-+		 * reachable, at least in the obvious cases (such as the case
-+		 * ending with a 'break'.
-+		 *
-+		 * Perhaps duk__parse_stmt() could provide some info on whether
-+		 * the statement is a "dead end"?
-+		 *
-+		 * If implemented, just set pc_prevstmt to -1 when not needed.
-+		 */
-+	}
-+
-+	DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RCURLY);
-+	duk__advance(comp_ctx);
-+
-+	/* default case control flow patchup; note that if pc_prevcase < 0
-+	 * (i.e. no case clauses), control enters default case automatically.
-+	 */
-+	if (pc_default >= 0) {
-+		/* default case exists: go there if no case matches */
-+		duk__patch_jump(comp_ctx, pc_prevcase, pc_default);
-+	} else {
-+		/* default case does not exist, or no statements present
-+		 * after default case: finish case evaluation
-+		 */
-+		duk__patch_jump_here(comp_ctx, pc_prevcase);
-+	}
-+
-+	/* fall-through control flow patchup; note that pc_prevstmt may be
-+	 * < 0 (i.e. no case clauses), in which case this is a no-op.
-+	 */
-+	duk__patch_jump_here(comp_ctx, pc_prevstmt);
-+
-+	/* continue jump not patched, an INVALID opcode remains there */
-+	duk__patch_jump_here(comp_ctx, pc_label_site + 1);  /* break jump */
-+
-+	/* Note: 'fast' breaks will jump to pc_label_site + 1, which will
-+	 * then jump here.  The double jump will be eliminated by a
-+	 * peephole pass, resulting in an optimal jump here.  The label
-+	 * site jumps will remain in bytecode and will waste code size.
-+	 */
-+
-+	return;
-+
-+ syntax_error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_SWITCH);
-+}
-+
-+DUK_LOCAL void duk__parse_if_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_reg_t temp_reset;
-+	duk_regconst_t rc_cond;
-+	duk_int_t pc_jump_false;
-+
-+	DUK_DDD(DUK_DDDPRINT("begin parsing if statement"));
-+
-+	temp_reset = DUK__GETTEMP(comp_ctx);
-+
-+	duk__advance(comp_ctx);  /* eat 'if' */
-+	duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
-+
-+	rc_cond = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+	duk__emit_if_true_skip(comp_ctx, rc_cond);
-+	pc_jump_false = duk__emit_jump_empty(comp_ctx);  /* jump to end or else part */
-+	DUK__SETTEMP(comp_ctx, temp_reset);
-+
-+	duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+
-+	duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
-+
-+	/* The 'else' ambiguity is resolved by 'else' binding to the innermost
-+	 * construct, so greedy matching is correct here.
-+	 */
-+
-+	if (comp_ctx->curr_token.t == DUK_TOK_ELSE) {
-+		duk_int_t pc_jump_end;
-+
-+		DUK_DDD(DUK_DDDPRINT("if has else part"));
-+
-+		duk__advance(comp_ctx);
-+
-+		pc_jump_end = duk__emit_jump_empty(comp_ctx);  /* jump from true part to end */
-+		duk__patch_jump_here(comp_ctx, pc_jump_false);
-+
-+		duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
-+
-+		duk__patch_jump_here(comp_ctx, pc_jump_end);
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("if does not have else part"));
-+
-+		duk__patch_jump_here(comp_ctx, pc_jump_false);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("end parsing if statement"));
-+}
-+
-+DUK_LOCAL void duk__parse_do_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
-+	duk_regconst_t rc_cond;
-+	duk_int_t pc_start;
-+
-+	DUK_DDD(DUK_DDDPRINT("begin parsing do statement"));
-+
-+	duk__advance(comp_ctx);  /* eat 'do' */
-+
-+	pc_start = duk__get_current_pc(comp_ctx);
-+	duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
-+	duk__patch_jump_here(comp_ctx, pc_label_site + 2);  /* continue jump */
-+
-+	duk__advance_expect(comp_ctx, DUK_TOK_WHILE);
-+	duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
-+
-+	rc_cond = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+	duk__emit_if_false_skip(comp_ctx, rc_cond);
-+	duk__emit_jump(comp_ctx, pc_start);
-+	/* no need to reset temps, as we're finished emitting code */
-+
-+	duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+
-+	duk__patch_jump_here(comp_ctx, pc_label_site + 1);  /* break jump */
-+
-+	DUK_DDD(DUK_DDDPRINT("end parsing do statement"));
-+}
-+
-+DUK_LOCAL void duk__parse_while_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_int_t pc_label_site) {
-+	duk_reg_t temp_reset;
-+	duk_regconst_t rc_cond;
-+	duk_int_t pc_start;
-+	duk_int_t pc_jump_false;
-+
-+	DUK_DDD(DUK_DDDPRINT("begin parsing while statement"));
-+
-+	temp_reset = DUK__GETTEMP(comp_ctx);
-+
-+	duk__advance(comp_ctx);  /* eat 'while' */
-+
-+	duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
-+
-+	pc_start = duk__get_current_pc(comp_ctx);
-+	duk__patch_jump_here(comp_ctx, pc_label_site + 2);  /* continue jump */
-+
-+	rc_cond = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+	duk__emit_if_true_skip(comp_ctx, rc_cond);
-+	pc_jump_false = duk__emit_jump_empty(comp_ctx);
-+	DUK__SETTEMP(comp_ctx, temp_reset);
-+
-+	duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+
-+	duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
-+	duk__emit_jump(comp_ctx, pc_start);
-+
-+	duk__patch_jump_here(comp_ctx, pc_jump_false);
-+	duk__patch_jump_here(comp_ctx, pc_label_site + 1);  /* break jump */
-+
-+	DUK_DDD(DUK_DDDPRINT("end parsing while statement"));
-+}
-+
-+DUK_LOCAL void duk__parse_break_or_continue_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_bool_t is_break = (comp_ctx->curr_token.t == DUK_TOK_BREAK);
-+	duk_int_t label_id;
-+	duk_int_t label_catch_depth;
-+	duk_int_t label_pc;  /* points to LABEL; pc+1 = jump site for break; pc+2 = jump site for continue */
-+	duk_bool_t label_is_closest;
-+
-+	DUK_UNREF(res);
-+
-+	duk__advance(comp_ctx);  /* eat 'break' or 'continue' */
-+
-+	if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON ||  /* explicit semi follows */
-+	    comp_ctx->curr_token.lineterm ||                /* automatic semi will be inserted */
-+	    comp_ctx->curr_token.allow_auto_semi) {         /* automatic semi will be inserted */
-+		/* break/continue without label */
-+
-+		duk__lookup_active_label(comp_ctx, DUK_HTHREAD_STRING_EMPTY_STRING(thr), is_break, &label_id, &label_catch_depth, &label_pc, &label_is_closest);
-+	} else if (comp_ctx->curr_token.t == DUK_TOK_IDENTIFIER) {
-+		/* break/continue with label (label cannot be a reserved word, production is 'Identifier' */
-+		DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
-+		duk__lookup_active_label(comp_ctx, comp_ctx->curr_token.str1, is_break, &label_id, &label_catch_depth, &label_pc, &label_is_closest);
-+		duk__advance(comp_ctx);
-+	} else {
-+		DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_BREAK_CONT_LABEL);
-+	}
-+
-+	/* Use a fast break/continue when possible.  A fast break/continue is
-+	 * just a jump to the LABEL break/continue jump slot, which then jumps
-+	 * to an appropriate place (for break, going through ENDLABEL correctly).
-+	 * The peephole optimizer will optimize the jump to a direct one.
-+	 */
-+
-+	if (label_catch_depth == comp_ctx->curr_func.catch_depth &&
-+	    label_is_closest) {
-+		DUK_DDD(DUK_DDDPRINT("break/continue: is_break=%ld, label_id=%ld, label_is_closest=%ld, "
-+		                     "label_catch_depth=%ld, catch_depth=%ld "
-+		                     "-> use fast variant (direct jump)",
-+		                     (long) is_break, (long) label_id, (long) label_is_closest,
-+		                     (long) label_catch_depth, (long) comp_ctx->curr_func.catch_depth));
-+
-+		duk__emit_jump(comp_ctx, label_pc + (is_break ? 1 : 2));
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("break/continue: is_break=%ld, label_id=%ld, label_is_closest=%ld, "
-+		                     "label_catch_depth=%ld, catch_depth=%ld "
-+		                     "-> use slow variant (longjmp)",
-+		                     (long) is_break, (long) label_id, (long) label_is_closest,
-+		                     (long) label_catch_depth, (long) comp_ctx->curr_func.catch_depth));
-+
-+		duk__emit_extraop_bc(comp_ctx,
-+		              is_break ? DUK_EXTRAOP_BREAK : DUK_EXTRAOP_CONTINUE,
-+		              (duk_regconst_t) label_id);
-+	}
-+}
-+
-+DUK_LOCAL void duk__parse_return_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_regconst_t rc_val;
-+	duk_small_uint_t ret_flags;
-+
-+	duk__advance(comp_ctx);  /* eat 'return' */
-+
-+	/* A 'return' statement is only allowed inside an actual function body,
-+	 * not as part of eval or global code.
-+	 */
-+	if (!comp_ctx->curr_func.is_function) {
-+		DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_RETURN);
-+	}
-+
-+	/* Use a fast return when possible.  A fast return does not cause a longjmp()
-+	 * unnecessarily.  A fast return can be done when no TCF catchers are active
-+	 * (this includes 'try' and 'with' statements).  Active label catches do not
-+	 * prevent a fast return; they're unwound on return automatically.
-+	 */
-+
-+	ret_flags = 0;
-+
-+	if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON ||  /* explicit semi follows */
-+	    comp_ctx->curr_token.lineterm ||                /* automatic semi will be inserted */
-+	    comp_ctx->curr_token.allow_auto_semi) {         /* automatic semi will be inserted */
-+		DUK_DDD(DUK_DDDPRINT("empty return value -> undefined"));
-+		rc_val = 0;
-+	} else {
-+		duk_int_t pc_before_expr;
-+		duk_int_t pc_after_expr;
-+
-+		DUK_DDD(DUK_DDDPRINT("return with a value"));
-+
-+		DUK_UNREF(pc_before_expr);
-+		DUK_UNREF(pc_after_expr);
-+
-+		pc_before_expr = duk__get_current_pc(comp_ctx);
-+		rc_val = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+		pc_after_expr = duk__get_current_pc(comp_ctx);
-+
-+		/* Tail call check: if last opcode emitted was CALL(I), and
-+		 * the context allows it, change the CALL(I) to a tailcall.
-+		 * This doesn't guarantee that a tailcall will be allowed at
-+		 * runtime, so the RETURN must still be emitted.  (Duktape
-+		 * 0.10.0 avoided this and simulated a RETURN if a tailcall
-+		 * couldn't be used at runtime; but this didn't work
-+		 * correctly with a thread yield/resume, see
-+		 * test-bug-tailcall-thread-yield-resume.js for discussion.)
-+		 *
-+		 * In addition to the last opcode being CALL, we also need to
-+		 * be sure that 'rc_val' is the result register of the CALL(I).
-+		 * For instance, for the expression 'return 0, (function ()
-+		 * { return 1; }), 2' the last opcode emitted is CALL (no
-+		 * bytecode is emitted for '2') but 'rc_val' indicates
-+		 * constant '2'.  Similarly if '2' is replaced by a register
-+		 * bound variable, no opcodes are emitted but tailcall would
-+		 * be incorrect.
-+		 *
-+		 * This is tricky and easy to get wrong.  It would be best to
-+		 * track enough expression metadata to check that 'rc_val' came
-+		 * from that last CALL instruction.  We don't have that metadata
-+		 * now, so we check that 'rc_val' is a temporary register result
-+		 * (not a constant or a register bound variable).  There should
-+		 * be no way currently for 'rc_val' to be a temporary for an
-+		 * expression following the CALL instruction without emitting
-+		 * some opcodes following the CALL.  This proxy check is used
-+		 * below.
-+		 *
-+		 * See: test-bug-comma-expr-gh131.js.
-+		 *
-+		 * The non-standard 'caller' property disables tail calls
-+		 * because they pose some special cases which haven't been
-+		 * fixed yet.
-+		 */
-+
-+#if defined(DUK_USE_TAILCALL)
-+		if (comp_ctx->curr_func.catch_depth == 0 &&   /* no catchers */
-+		    pc_after_expr > pc_before_expr) {         /* at least one opcode emitted */
-+			duk_compiler_instr *instr;
-+			duk_small_uint_t op;
-+
-+			instr = duk__get_instr_ptr(comp_ctx, pc_after_expr - 1);
-+			DUK_ASSERT(instr != NULL);
-+
-+			op = (duk_small_uint_t) DUK_DEC_OP(instr->ins);
-+			if ((op == DUK_OP_CALL || op == DUK_OP_CALLI) &&
-+			    DUK__ISTEMP(comp_ctx, rc_val) /* see above */) {
-+				DUK_DDD(DUK_DDDPRINT("return statement detected a tail call opportunity: "
-+				                     "catch depth is 0, duk__exprtop() emitted >= 1 instructions, "
-+				                     "and last instruction is a CALL "
-+				                     "-> set TAILCALL flag"));
-+				/* Just flip the single bit. */
-+				instr->ins |= DUK_ENC_OP_A_B_C(0, DUK_BC_CALL_FLAG_TAILCALL, 0, 0);
-+			}
-+		}
-+#endif  /* DUK_USE_TAILCALL */
-+
-+		ret_flags = DUK_BC_RETURN_FLAG_HAVE_RETVAL;
-+	}
-+
-+	/* XXX: For now, "fast returns" are disabled.  The compiler doesn't track
-+	 * label site depth so when it emits a fast return, it doesn't know whether
-+	 * label sites exist or not.  Label sites are emitted for e.g. for loops,
-+	 * so it's probably quite relevant to handle them in the executor's fast
-+	 * return handler.
-+	 */
-+#if 0
-+	if (comp_ctx->curr_func.catch_depth == 0) {
-+		DUK_DDD(DUK_DDDPRINT("fast return allowed -> use fast return"));
-+		ret_flags |= DUK_BC_RETURN_FLAG_FAST;
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("fast return not allowed -> use slow return"));
-+	}
-+#endif
-+
-+	duk__emit_a_b(comp_ctx,
-+	              DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A,
-+	              (duk_regconst_t) ret_flags /*flags*/,
-+	              rc_val /*reg*/);
-+}
-+
-+DUK_LOCAL void duk__parse_throw_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_reg_t reg_val;
-+
-+	duk__advance(comp_ctx);  /* eat 'throw' */
-+
-+	/* Unlike break/continue, throw statement does not allow an empty value. */
-+
-+	if (comp_ctx->curr_token.lineterm) {
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_THROW);
-+	}
-+
-+	reg_val = duk__exprtop_toreg(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+	duk__emit_extraop_bc(comp_ctx,
-+	                     DUK_EXTRAOP_THROW,
-+	                     (duk_regconst_t) reg_val);
-+}
-+
-+DUK_LOCAL void duk__parse_try_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_reg_t reg_catch;      /* reg_catch+0 and reg_catch+1 are reserved for TRYCATCH */
-+	duk_regconst_t rc_varname = 0;
-+	duk_small_uint_t trycatch_flags = 0;
-+	duk_int_t pc_trycatch = -1;
-+	duk_int_t pc_catch = -1;
-+	duk_int_t pc_finally = -1;
-+
-+	DUK_UNREF(res);
-+
-+	/*
-+	 *  See the following documentation for discussion:
-+	 *
-+	 *    doc/execution.txt: control flow details
-+	 *
-+	 *  Try, catch, and finally "parts" are Blocks, not Statements, so
-+	 *  they must always be delimited by curly braces.  This is unlike e.g.
-+	 *  the if statement, which accepts any Statement.  This eliminates any
-+	 *  questions of matching parts of nested try statements.  The Block
-+	 *  parsing is implemented inline here (instead of calling out).
-+	 *
-+	 *  Finally part has a 'let scoped' variable, which requires a few kinks
-+	 *  here.
-+	 */
-+
-+	comp_ctx->curr_func.catch_depth++;
-+
-+	duk__advance(comp_ctx);  /* eat 'try' */
-+
-+	reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2);
-+
-+	pc_trycatch = duk__get_current_pc(comp_ctx);
-+	duk__emit_invalid(comp_ctx);  /* TRYCATCH, cannot emit now (not enough info) */
-+	duk__emit_invalid(comp_ctx);  /* jump for 'catch' case */
-+	duk__emit_invalid(comp_ctx);  /* jump for 'finally' case or end (if no finally) */
-+
-+	/* try part */
-+	duk__advance_expect(comp_ctx, DUK_TOK_LCURLY);
-+	duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
-+	/* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
-+	duk__emit_extraop_only(comp_ctx,
-+	                       DUK_EXTRAOP_ENDTRY);
-+
-+	if (comp_ctx->curr_token.t == DUK_TOK_CATCH) {
-+		/*
-+		 *  The catch variable must be updated to reflect the new allocated
-+		 *  register for the duration of the catch clause.  We need to store
-+		 *  and restore the original value for the varmap entry (if any).
-+		 */
-+
-+		/*
-+		 *  Note: currently register bindings must be fixed for the entire
-+		 *  function.  So, even though the catch variable is in a register
-+		 *  we know, we must use an explicit environment record and slow path
-+		 *  accesses to read/write the catch binding to make closures created
-+		 *  within the catch clause work correctly.  This restriction should
-+		 *  be fixable (at least in common cases) later.
-+		 *
-+		 *  See: test-bug-catch-binding-2.js.
-+		 *
-+		 *  XXX: improve to get fast path access to most catch clauses.
-+		 */
-+
-+		duk_hstring *h_var;
-+		duk_int_t varmap_value;  /* for storing/restoring the varmap binding for catch variable */
-+
-+		DUK_DDD(DUK_DDDPRINT("stack top at start of catch clause: %ld", (long) duk_get_top(ctx)));
-+
-+		trycatch_flags |= DUK_BC_TRYCATCH_FLAG_HAVE_CATCH;
-+
-+		pc_catch = duk__get_current_pc(comp_ctx);
-+
-+		duk__advance(comp_ctx);
-+		duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
-+
-+		if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) {
-+			/* Identifier, i.e. don't allow reserved words */
-+			goto syntax_error;
-+		}
-+		h_var = comp_ctx->curr_token.str1;
-+		DUK_ASSERT(h_var != NULL);
-+
-+		duk_push_hstring(ctx, h_var);  /* keep in on valstack, use borrowed ref below */
-+
-+		if (comp_ctx->curr_func.is_strict &&
-+		    ((h_var == DUK_HTHREAD_STRING_EVAL(thr)) ||
-+		     (h_var == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)))) {
-+			DUK_DDD(DUK_DDDPRINT("catch identifier 'eval' or 'arguments' in strict mode -> SyntaxError"));
-+			goto syntax_error;
-+		}
-+
-+		duk_dup_top(ctx);
-+		rc_varname = duk__getconst(comp_ctx);
-+		DUK_DDD(DUK_DDDPRINT("catch clause, rc_varname=0x%08lx (%ld)",
-+		                     (unsigned long) rc_varname, (long) rc_varname));
-+
-+		duk__advance(comp_ctx);
-+		duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+
-+		duk__advance_expect(comp_ctx, DUK_TOK_LCURLY);
-+
-+		DUK_DDD(DUK_DDDPRINT("varmap before modifying for catch clause: %!iT",
-+		                     (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
-+
-+		duk_dup_top(ctx);
-+		duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);
-+		if (duk_is_undefined(ctx, -1)) {
-+			varmap_value = -2;
-+		} else if (duk_is_null(ctx, -1)) {
-+			varmap_value = -1;
-+		} else {
-+			DUK_ASSERT(duk_is_number(ctx, -1));
-+			varmap_value = duk_get_int(ctx, -1);
-+			DUK_ASSERT(varmap_value >= 0);
-+		}
-+		duk_pop(ctx);
-+
-+#if 0
-+		/* It'd be nice to do something like this - but it doesn't
-+		 * work for closures created inside the catch clause.
-+		 */
-+		duk_dup_top(ctx);
-+		duk_push_int(ctx, (duk_int_t) (reg_catch + 0));
-+		duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
-+#endif
-+		duk_dup_top(ctx);
-+		duk_push_null(ctx);
-+		duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
-+
-+		duk__emit_a_bc(comp_ctx,
-+		               DUK_OP_PUTVAR | DUK__EMIT_FLAG_A_IS_SOURCE,
-+		               (duk_regconst_t) (reg_catch + 0) /*value*/,
-+		               rc_varname /*varname*/);
-+
-+		DUK_DDD(DUK_DDDPRINT("varmap before parsing catch clause: %!iT",
-+		                     (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
-+
-+		duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
-+		/* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
-+
-+		if (varmap_value == -2) {
-+			/* not present */
-+			duk_del_prop(ctx, comp_ctx->curr_func.varmap_idx);
-+		} else {
-+			if (varmap_value == -1) {
-+				duk_push_null(ctx);
-+			} else {
-+				DUK_ASSERT(varmap_value >= 0);
-+				duk_push_int(ctx, varmap_value);
-+			}
-+			duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);
-+		}
-+		/* varname is popped by above code */
-+
-+		DUK_DDD(DUK_DDDPRINT("varmap after restore catch clause: %!iT",
-+		                     (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx)));
-+
-+		duk__emit_extraop_only(comp_ctx,
-+		                       DUK_EXTRAOP_ENDCATCH);
-+
-+		/*
-+		 *  XXX: for now, indicate that an expensive catch binding
-+		 *  declarative environment is always needed.  If we don't
-+		 *  need it, we don't need the const_varname either.
-+		 */
-+
-+		trycatch_flags |= DUK_BC_TRYCATCH_FLAG_CATCH_BINDING;
-+
-+		DUK_DDD(DUK_DDDPRINT("stack top at end of catch clause: %ld", (long) duk_get_top(ctx)));
-+	}
-+
-+	if (comp_ctx->curr_token.t == DUK_TOK_FINALLY) {
-+		trycatch_flags |= DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY;
-+
-+		pc_finally = duk__get_current_pc(comp_ctx);
-+
-+		duk__advance(comp_ctx);
-+
-+		duk__advance_expect(comp_ctx, DUK_TOK_LCURLY);
-+		duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
-+		/* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
-+		duk__emit_extraop_b(comp_ctx,
-+		                    DUK_EXTRAOP_ENDFIN,
-+		                    reg_catch);  /* rethrow */
-+	}
-+
-+	if (!(trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) &&
-+	    !(trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY)) {
-+		/* must have catch and/or finally */
-+		goto syntax_error;
-+	}
-+
-+	duk__patch_trycatch(comp_ctx,
-+	                    pc_trycatch,
-+	                    reg_catch,
-+	                    rc_varname,
-+	                    trycatch_flags);
-+
-+	if (trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) {
-+		DUK_ASSERT(pc_catch >= 0);
-+		duk__patch_jump(comp_ctx, pc_trycatch + 1, pc_catch);
-+	}
-+
-+	if (trycatch_flags & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY) {
-+		DUK_ASSERT(pc_finally >= 0);
-+		duk__patch_jump(comp_ctx, pc_trycatch + 2, pc_finally);
-+	} else {
-+		/* without finally, the second jump slot is used to jump to end of stmt */
-+		duk__patch_jump_here(comp_ctx, pc_trycatch + 2);
-+	}
-+
-+	comp_ctx->curr_func.catch_depth--;
-+	return;
-+
-+ syntax_error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_TRY);
-+}
-+
-+DUK_LOCAL void duk__parse_with_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res) {
-+	duk_int_t pc_trycatch;
-+	duk_int_t pc_finished;
-+	duk_reg_t reg_catch;
-+	duk_regconst_t rc_target;
-+	duk_small_uint_t trycatch_flags;
-+
-+	if (comp_ctx->curr_func.is_strict) {
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_WITH_IN_STRICT_MODE);
-+	}
-+
-+	comp_ctx->curr_func.catch_depth++;
-+
-+	duk__advance(comp_ctx);  /* eat 'with' */
-+
-+	reg_catch = DUK__ALLOCTEMPS(comp_ctx, 2);
-+
-+	duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
-+	rc_target = duk__exprtop_toregconst(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+	duk__advance_expect(comp_ctx, DUK_TOK_RPAREN);
-+
-+	/* XXX: the trycatch shuffle flags are now very limiting and a fix
-+	 * is needed to allow trycatch to work in functions with a very large
-+	 * number of temporaries or constants.
-+	 */
-+
-+	pc_trycatch = duk__get_current_pc(comp_ctx);
-+	trycatch_flags = DUK_BC_TRYCATCH_FLAG_WITH_BINDING;
-+	duk__emit_a_b_c(comp_ctx,
-+	                DUK_OP_TRYCATCH | DUK__EMIT_FLAG_NO_SHUFFLE_A
-+	                                | DUK__EMIT_FLAG_NO_SHUFFLE_B
-+	                                | DUK__EMIT_FLAG_NO_SHUFFLE_C,
-+	                (duk_regconst_t) trycatch_flags /*a*/,
-+	                (duk_regconst_t) reg_catch /*b*/,
-+	                rc_target /*c*/);
-+	duk__emit_invalid(comp_ctx);  /* catch jump */
-+	duk__emit_invalid(comp_ctx);  /* finished jump */
-+
-+	duk__parse_stmt(comp_ctx, res, 0 /*allow_source_elem*/);
-+	duk__emit_extraop_only(comp_ctx,
-+	                       DUK_EXTRAOP_ENDTRY);
-+
-+	pc_finished = duk__get_current_pc(comp_ctx);
-+
-+	duk__patch_jump(comp_ctx, pc_trycatch + 2, pc_finished);
-+
-+	comp_ctx->curr_func.catch_depth--;
-+}
-+
-+DUK_LOCAL duk_int_t duk__stmt_label_site(duk_compiler_ctx *comp_ctx, duk_int_t label_id) {
-+	/* if a site already exists, nop: max one label site per statement */
-+	if (label_id >= 0) {
-+		return label_id;
-+	}
-+
-+	label_id = comp_ctx->curr_func.label_next++;
-+	DUK_DDD(DUK_DDDPRINT("allocated new label id for label site: %ld", (long) label_id));
-+
-+	duk__emit_extraop_bc(comp_ctx,
-+	                     DUK_EXTRAOP_LABEL,
-+	                     (duk_regconst_t) label_id);
-+	duk__emit_invalid(comp_ctx);
-+	duk__emit_invalid(comp_ctx);
-+
-+	return label_id;
-+}
-+
-+/* Parse a single statement.
-+ *
-+ * Creates a label site (with an empty label) automatically for iteration
-+ * statements.  Also "peels off" any label statements for explicit labels.
-+ */
-+DUK_LOCAL void duk__parse_stmt(duk_compiler_ctx *comp_ctx, duk_ivalue *res, duk_bool_t allow_source_elem) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_bool_t dir_prol_at_entry;    /* directive prologue status at entry */
-+	duk_reg_t temp_at_entry;
-+	duk_uarridx_t labels_len_at_entry;
-+	duk_int_t pc_at_entry;           /* assumed to also be PC of "LABEL" */
-+	duk_int_t stmt_id;
-+	duk_small_uint_t stmt_flags = 0;
-+	duk_int_t label_id = -1;
-+	duk_small_uint_t tok;
-+
-+	DUK__RECURSION_INCREASE(comp_ctx, thr);
-+
-+	temp_at_entry = DUK__GETTEMP(comp_ctx);
-+	pc_at_entry = duk__get_current_pc(comp_ctx);
-+	labels_len_at_entry = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.labelnames_idx);
-+	stmt_id = comp_ctx->curr_func.stmt_next++;
-+	dir_prol_at_entry = comp_ctx->curr_func.in_directive_prologue;
-+
-+	DUK_UNREF(stmt_id);
-+
-+	DUK_DDD(DUK_DDDPRINT("parsing a statement, stmt_id=%ld, temp_at_entry=%ld, labels_len_at_entry=%ld, "
-+	                     "is_strict=%ld, in_directive_prologue=%ld, catch_depth=%ld",
-+	                     (long) stmt_id, (long) temp_at_entry, (long) labels_len_at_entry,
-+	                     (long) comp_ctx->curr_func.is_strict, (long) comp_ctx->curr_func.in_directive_prologue,
-+	                     (long) comp_ctx->curr_func.catch_depth));
-+
-+	/* The directive prologue flag is cleared by default so that it is
-+	 * unset for any recursive statement parsing.  It is only "revived"
-+	 * if a directive is detected.  (We could also make directives only
-+	 * allowed if 'allow_source_elem' was true.)
-+	 */
-+	comp_ctx->curr_func.in_directive_prologue = 0;
-+
-+ retry_parse:
-+
-+	DUK_DDD(DUK_DDDPRINT("try stmt parse, stmt_id=%ld, label_id=%ld, allow_source_elem=%ld, catch_depth=%ld",
-+	                     (long) stmt_id, (long) label_id, (long) allow_source_elem,
-+	                     (long) comp_ctx->curr_func.catch_depth));
-+
-+	/*
-+	 *  Detect iteration statements; if encountered, establish an
-+	 *  empty label.
-+	 */
-+
-+	tok = comp_ctx->curr_token.t;
-+	if (tok == DUK_TOK_FOR || tok == DUK_TOK_DO || tok == DUK_TOK_WHILE ||
-+	    tok == DUK_TOK_SWITCH) {
-+		DUK_DDD(DUK_DDDPRINT("iteration/switch statement -> add empty label"));
-+
-+		label_id = duk__stmt_label_site(comp_ctx, label_id);
-+		duk__add_label(comp_ctx,
-+		               DUK_HTHREAD_STRING_EMPTY_STRING(thr),
-+		               pc_at_entry /*pc_label*/,
-+		               label_id);
-+	}
-+
-+	/*
-+	 *  Main switch for statement / source element type.
-+	 */
-+
-+	switch (comp_ctx->curr_token.t) {
-+	case DUK_TOK_FUNCTION: {
-+		/*
-+		 *  Function declaration, function expression, or (non-standard)
-+		 *  function statement.
-+		 *
-+		 *  The E5 specification only allows function declarations at
-+		 *  the top level (in "source elements").  An ExpressionStatement
-+		 *  is explicitly not allowed to begin with a "function" keyword
-+		 *  (E5 Section 12.4).  Hence any non-error semantics for such
-+		 *  non-top-level statements are non-standard.  Duktape semantics
-+		 *  for function statements are modelled after V8, see
-+		 *  test-dev-func-decl-outside-top.js.
-+		 */
-+
-+#if defined(DUK_USE_NONSTD_FUNC_STMT)
-+		/* Lenient: allow function declarations outside top level in
-+		 * non-strict mode but reject them in strict mode.
-+		 */
-+		if (allow_source_elem || !comp_ctx->curr_func.is_strict)
-+#else  /* DUK_USE_NONSTD_FUNC_STMT */
-+		/* Strict: never allow function declarations outside top level. */
-+		if (allow_source_elem)
-+#endif  /* DUK_USE_NONSTD_FUNC_STMT */
-+		{
-+			/* FunctionDeclaration: not strictly a statement but handled as such.
-+			 *
-+			 * O(depth^2) parse count for inner functions is handled by recording a
-+			 * lexer offset on the first compilation pass, so that the function can
-+			 * be efficiently skipped on the second pass.  This is encapsulated into
-+			 * duk__parse_func_like_fnum().
-+			 */
-+
-+			duk_int_t fnum;
-+
-+			DUK_DDD(DUK_DDDPRINT("function declaration statement"));
-+
-+			duk__advance(comp_ctx);  /* eat 'function' */
-+			fnum = duk__parse_func_like_fnum(comp_ctx, 1 /*is_decl*/, 0 /*is_setget*/);
-+
-+			if (comp_ctx->curr_func.in_scanning) {
-+				duk_uarridx_t n;
-+				duk_hstring *h_funcname;
-+
-+				duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, fnum * 3);
-+				duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME);  /* -> [ ... func name ] */
-+				h_funcname = duk_get_hstring(ctx, -1);
-+				DUK_ASSERT(h_funcname != NULL);
-+
-+				DUK_DDD(DUK_DDDPRINT("register function declaration %!O in pass 1, fnum %ld",
-+				                     (duk_heaphdr *) h_funcname, (long) fnum));
-+				n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
-+				duk_push_hstring(ctx, h_funcname);
-+				duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n);
-+				duk_push_int(ctx, (duk_int_t) (DUK_DECL_TYPE_FUNC + (fnum << 8)));
-+				duk_put_prop_index(ctx, comp_ctx->curr_func.decls_idx, n + 1);
-+
-+				duk_pop_n(ctx, 2);
-+			}
-+
-+			/* no statement value (unlike function expression) */
-+			stmt_flags = 0;
-+			break;
-+		} else {
-+			DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_FUNC_STMT_NOT_ALLOWED);
-+		}
-+		break;
-+	}
-+	case DUK_TOK_LCURLY: {
-+		DUK_DDD(DUK_DDDPRINT("block statement"));
-+		duk__advance(comp_ctx);
-+		duk__parse_stmts(comp_ctx, 0 /*allow_source_elem*/, 0 /*expect_eof*/);
-+		/* the DUK_TOK_RCURLY is eaten by duk__parse_stmts() */
-+		if (label_id >= 0) {
-+			duk__patch_jump_here(comp_ctx, pc_at_entry + 1);  /* break jump */
-+		}
-+		stmt_flags = 0;
-+		break;
-+	}
-+	case DUK_TOK_VAR: {
-+		DUK_DDD(DUK_DDDPRINT("variable declaration statement"));
-+		duk__parse_var_stmt(comp_ctx, res);
-+		stmt_flags = DUK__HAS_TERM;
-+		break;
-+	}
-+	case DUK_TOK_SEMICOLON: {
-+		/* empty statement with an explicit semicolon */
-+		DUK_DDD(DUK_DDDPRINT("empty statement"));
-+		stmt_flags = DUK__HAS_TERM;
-+		break;
-+	}
-+	case DUK_TOK_IF: {
-+		DUK_DDD(DUK_DDDPRINT("if statement"));
-+		duk__parse_if_stmt(comp_ctx, res);
-+		if (label_id >= 0) {
-+			duk__patch_jump_here(comp_ctx, pc_at_entry + 1);  /* break jump */
-+		}
-+		stmt_flags = 0;
-+		break;
-+	}
-+	case DUK_TOK_DO: {
-+		/*
-+		 *  Do-while statement is mostly trivial, but there is special
-+		 *  handling for automatic semicolon handling (triggered by the
-+		 *  DUK__ALLOW_AUTO_SEMI_ALWAYS) flag related to a bug filed at:
-+		 *
-+		 *    https://bugs.ecmascript.org/show_bug.cgi?id=8
-+		 *
-+		 *  See doc/compiler.txt for details.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("do statement"));
-+		DUK_ASSERT(label_id >= 0);
-+		duk__update_label_flags(comp_ctx,
-+		                        label_id,
-+		                        DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
-+		duk__parse_do_stmt(comp_ctx, res, pc_at_entry);
-+		stmt_flags = DUK__HAS_TERM | DUK__ALLOW_AUTO_SEMI_ALWAYS;  /* DUK__ALLOW_AUTO_SEMI_ALWAYS workaround */
-+		break;
-+	}
-+	case DUK_TOK_WHILE: {
-+		DUK_DDD(DUK_DDDPRINT("while statement"));
-+		DUK_ASSERT(label_id >= 0);
-+		duk__update_label_flags(comp_ctx,
-+		                        label_id,
-+		                        DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
-+		duk__parse_while_stmt(comp_ctx, res, pc_at_entry);
-+		stmt_flags = 0;
-+		break;
-+	}
-+	case DUK_TOK_FOR: {
-+		/*
-+		 *  For/for-in statement is complicated to parse because
-+		 *  determining the statement type (three-part for vs. a
-+		 *  for-in) requires potential backtracking.
-+		 *
-+		 *  See the helper for the messy stuff.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("for/for-in statement"));
-+		DUK_ASSERT(label_id >= 0);
-+		duk__update_label_flags(comp_ctx,
-+		                        label_id,
-+		                        DUK_LABEL_FLAG_ALLOW_BREAK | DUK_LABEL_FLAG_ALLOW_CONTINUE);
-+		duk__parse_for_stmt(comp_ctx, res, pc_at_entry);
-+		stmt_flags = 0;
-+		break;
-+	}
-+	case DUK_TOK_CONTINUE:
-+	case DUK_TOK_BREAK: {
-+		DUK_DDD(DUK_DDDPRINT("break/continue statement"));
-+		duk__parse_break_or_continue_stmt(comp_ctx, res);
-+		stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
-+		break;
-+	}
-+	case DUK_TOK_RETURN: {
-+		DUK_DDD(DUK_DDDPRINT("return statement"));
-+		duk__parse_return_stmt(comp_ctx, res);
-+		stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
-+		break;
-+	}
-+	case DUK_TOK_WITH: {
-+		DUK_DDD(DUK_DDDPRINT("with statement"));
-+		comp_ctx->curr_func.with_depth++;
-+		duk__parse_with_stmt(comp_ctx, res);
-+		if (label_id >= 0) {
-+			duk__patch_jump_here(comp_ctx, pc_at_entry + 1);  /* break jump */
-+		}
-+		comp_ctx->curr_func.with_depth--;
-+		stmt_flags = 0;
-+		break;
-+	}
-+	case DUK_TOK_SWITCH: {
-+		/*
-+		 *  The switch statement is pretty messy to compile.
-+		 *  See the helper for details.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("switch statement"));
-+		DUK_ASSERT(label_id >= 0);
-+		duk__update_label_flags(comp_ctx,
-+		                        label_id,
-+		                        DUK_LABEL_FLAG_ALLOW_BREAK);  /* don't allow continue */
-+		duk__parse_switch_stmt(comp_ctx, res, pc_at_entry);
-+		stmt_flags = 0;
-+		break;
-+	}
-+	case DUK_TOK_THROW: {
-+		DUK_DDD(DUK_DDDPRINT("throw statement"));
-+		duk__parse_throw_stmt(comp_ctx, res);
-+		stmt_flags = DUK__HAS_TERM | DUK__IS_TERMINAL;
-+		break;
-+	}
-+	case DUK_TOK_TRY: {
-+		DUK_DDD(DUK_DDDPRINT("try statement"));
-+		duk__parse_try_stmt(comp_ctx, res);
-+		stmt_flags = 0;
-+		break;
-+	}
-+	case DUK_TOK_DEBUGGER: {
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+		DUK_DDD(DUK_DDDPRINT("debugger statement: debugging enabled, emit debugger opcode"));
-+		duk__emit_extraop_only(comp_ctx, DUK_EXTRAOP_DEBUGGER);
-+#else
-+		DUK_DDD(DUK_DDDPRINT("debugger statement: ignored"));
-+#endif
-+		duk__advance(comp_ctx);
-+		stmt_flags = DUK__HAS_TERM;
-+		break;
-+	}
-+	default: {
-+		/*
-+		 *  Else, must be one of:
-+		 *    - ExpressionStatement, possibly a directive (String)
-+		 *    - LabelledStatement (Identifier followed by ':')
-+		 *
-+		 *  Expressions beginning with 'function' keyword are covered by a case
-+		 *  above (such expressions are not allowed in standard E5 anyway).
-+		 *  Also expressions starting with '{' are interpreted as block
-+		 *  statements.  See E5 Section 12.4.
-+		 *
-+		 *  Directive detection is tricky; see E5 Section 14.1 on directive
-+		 *  prologue.  A directive is an expression statement with a single
-+		 *  string literal and an explicit or automatic semicolon.  Escape
-+		 *  characters are significant and no parens etc are allowed:
-+		 *
-+		 *    'use strict';          // valid 'use strict' directive
-+		 *    'use\u0020strict';     // valid directive, not a 'use strict' directive
-+		 *    ('use strict');        // not a valid directive
-+		 *
-+		 *  The expression is determined to consist of a single string literal
-+		 *  based on duk__expr_nud() and duk__expr_led() call counts.  The string literal
-+		 *  of a 'use strict' directive is determined to lack any escapes based
-+		 *  num_escapes count from the lexer.  Note that other directives may be
-+		 *  allowed to contain escapes, so a directive with escapes does not
-+		 *  terminate a directive prologue.
-+		 *
-+		 *  We rely on the fact that the expression parser will not emit any
-+		 *  code for a single token expression.  However, it will generate an
-+		 *  intermediate value which we will then successfully ignore.
-+		 *
-+		 *  A similar approach is used for labels.
-+		 */
-+
-+		duk_bool_t single_token;
-+
-+		DUK_DDD(DUK_DDDPRINT("expression statement"));
-+		duk__exprtop(comp_ctx, res, DUK__BP_FOR_EXPR /*rbp_flags*/);
-+
-+		single_token = (comp_ctx->curr_func.nud_count == 1 &&  /* one token */
-+		                comp_ctx->curr_func.led_count == 0);   /* no operators */
-+
-+		if (single_token &&
-+		    comp_ctx->prev_token.t == DUK_TOK_IDENTIFIER &&
-+		    comp_ctx->curr_token.t == DUK_TOK_COLON) {
-+			/*
-+			 *  Detected label
-+			 */
-+
-+			duk_hstring *h_lab;
-+
-+			/* expected ival */
-+			DUK_ASSERT(res->t == DUK_IVAL_VAR);
-+			DUK_ASSERT(res->x1.t == DUK_ISPEC_VALUE);
-+			DUK_ASSERT(DUK_TVAL_IS_STRING(duk_get_tval(ctx, res->x1.valstack_idx)));
-+			h_lab = comp_ctx->prev_token.str1;
-+			DUK_ASSERT(h_lab != NULL);
-+
-+			DUK_DDD(DUK_DDDPRINT("explicit label site for label '%!O'",
-+			                     (duk_heaphdr *) h_lab));
-+
-+			duk__advance(comp_ctx);  /* eat colon */
-+
-+			label_id = duk__stmt_label_site(comp_ctx, label_id);
-+
-+			duk__add_label(comp_ctx,
-+			               h_lab,
-+			               pc_at_entry /*pc_label*/,
-+			               label_id);
-+
-+			/* a statement following a label cannot be a source element
-+			 * (a function declaration).
-+			 */
-+			allow_source_elem = 0;
-+
-+			DUK_DDD(DUK_DDDPRINT("label handled, retry statement parsing"));
-+			goto retry_parse;
-+		}
-+
-+		stmt_flags = 0;
-+
-+		if (dir_prol_at_entry &&                           /* still in prologue */
-+		    single_token &&                                /* single string token */
-+		    comp_ctx->prev_token.t == DUK_TOK_STRING) {
-+			/*
-+			 *  Detected a directive
-+			 */
-+			duk_hstring *h_dir;
-+
-+			/* expected ival */
-+			DUK_ASSERT(res->t == DUK_IVAL_PLAIN);
-+			DUK_ASSERT(res->x1.t == DUK_ISPEC_VALUE);
-+			DUK_ASSERT(DUK_TVAL_IS_STRING(duk_get_tval(ctx, res->x1.valstack_idx)));
-+			h_dir = comp_ctx->prev_token.str1;
-+			DUK_ASSERT(h_dir != NULL);
-+
-+			DUK_DDD(DUK_DDDPRINT("potential directive: %!O", h_dir));
-+
-+			stmt_flags |= DUK__STILL_PROLOGUE;
-+
-+			/* Note: escaped characters differentiate directives */
-+
-+			if (comp_ctx->prev_token.num_escapes > 0) {
-+				DUK_DDD(DUK_DDDPRINT("directive contains escapes: valid directive "
-+				                     "but we ignore such directives"));
-+			} else {
-+				/*
-+				 * The length comparisons are present to handle
-+				 * strings like "use strict\u0000foo" as required.
-+				 */
-+
-+				if (DUK_HSTRING_GET_BYTELEN(h_dir) == 10 &&
-+				    DUK_STRNCMP((const char *) DUK_HSTRING_GET_DATA(h_dir), "use strict", 10) == 0) {
-+#if defined(DUK_USE_STRICT_DECL)
-+					DUK_DDD(DUK_DDDPRINT("use strict directive detected: strict flag %ld -> %ld",
-+					                     (long) comp_ctx->curr_func.is_strict, (long) 1));
-+					comp_ctx->curr_func.is_strict = 1;
-+#else
-+					DUK_DDD(DUK_DDDPRINT("use strict detected but strict declarations disabled, ignoring"));
-+#endif
-+				} else if (DUK_HSTRING_GET_BYTELEN(h_dir) == 14 &&
-+				           DUK_STRNCMP((const char *) DUK_HSTRING_GET_DATA(h_dir), "use duk notail", 14) == 0) {
-+					DUK_DDD(DUK_DDDPRINT("use duk notail directive detected: notail flag %ld -> %ld",
-+					                     (long) comp_ctx->curr_func.is_notail, (long) 1));
-+					comp_ctx->curr_func.is_notail = 1;
-+				} else {
-+					DUK_DD(DUK_DDPRINT("unknown directive: '%!O', ignoring but not terminating "
-+					                   "directive prologue", (duk_hobject *) h_dir));
-+				}
-+			}
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("non-directive expression statement or no longer in prologue; "
-+			                     "prologue terminated if still active"));
-+                }
-+
-+		stmt_flags |= DUK__HAS_VAL | DUK__HAS_TERM;
-+	}
-+	}  /* end switch (tok) */
-+
-+	/*
-+	 *  Statement value handling.
-+	 *
-+	 *  Global code and eval code has an implicit return value
-+	 *  which comes from the last statement with a value
-+	 *  (technically a non-"empty" continuation, which is
-+	 *  different from an empty statement).
-+	 *
-+	 *  Since we don't know whether a later statement will
-+	 *  override the value of the current statement, we need
-+	 *  to coerce the statement value to a register allocated
-+	 *  for implicit return values.  In other cases we need
-+	 *  to coerce the statement value to a plain value to get
-+	 *  any side effects out (consider e.g. "foo.bar;").
-+	 */
-+
-+	/* XXX: what about statements which leave a half-cooked value in 'res'
-+	 * but have no stmt value?  Any such statements?
-+	 */
-+
-+	if (stmt_flags & DUK__HAS_VAL) {
-+		duk_reg_t reg_stmt_value = comp_ctx->curr_func.reg_stmt_value;
-+		if (reg_stmt_value >= 0) {
-+			duk__ivalue_toforcedreg(comp_ctx, res, reg_stmt_value);
-+		} else {
-+			duk__ivalue_toplain_ignore(comp_ctx, res);
-+		}
-+	} else {
-+		;
-+	}
-+
-+	/*
-+	 *  Statement terminator check, including automatic semicolon
-+	 *  handling.  After this step, 'curr_tok' should be the first
-+	 *  token after a possible statement terminator.
-+	 */
-+
-+	if (stmt_flags & DUK__HAS_TERM) {
-+		if (comp_ctx->curr_token.t == DUK_TOK_SEMICOLON) {
-+			DUK_DDD(DUK_DDDPRINT("explicit semicolon terminates statement"));
-+			duk__advance(comp_ctx);
-+		} else {
-+			if (comp_ctx->curr_token.allow_auto_semi) {
-+				DUK_DDD(DUK_DDDPRINT("automatic semicolon terminates statement"));
-+			} else if (stmt_flags & DUK__ALLOW_AUTO_SEMI_ALWAYS) {
-+				/* XXX: make this lenience dependent on flags or strictness? */
-+				DUK_DDD(DUK_DDDPRINT("automatic semicolon terminates statement (allowed for compatibility "
-+				                     "even though no lineterm present before next token)"));
-+			} else {
-+				DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_UNTERMINATED_STMT);
-+			}
-+		}
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("statement has no terminator"));
-+	}
-+
-+	/*
-+	 *  Directive prologue tracking.
-+	 */
-+
-+	if (stmt_flags & DUK__STILL_PROLOGUE) {
-+		DUK_DDD(DUK_DDDPRINT("setting in_directive_prologue"));
-+		comp_ctx->curr_func.in_directive_prologue = 1;
-+	}
-+
-+	/*
-+	 *  Cleanups (all statement parsing flows through here).
-+	 *
-+	 *  Pop label site and reset labels.  Reset 'next temp' to value at
-+	 *  entry to reuse temps.
-+	 */
-+
-+	if (label_id >= 0) {
-+		duk__emit_extraop_bc(comp_ctx,
-+		                     DUK_EXTRAOP_ENDLABEL,
-+		                     (duk_regconst_t) label_id);
-+	}
-+
-+	DUK__SETTEMP(comp_ctx, temp_at_entry);
-+
-+	duk__reset_labels_to_length(comp_ctx, labels_len_at_entry);
-+
-+	/* XXX: return indication of "terminalness" (e.g. a 'throw' is terminal) */
-+
-+	DUK__RECURSION_DECREASE(comp_ctx, thr);
-+}
-+
-+#undef DUK__HAS_VAL
-+#undef DUK__HAS_TERM
-+#undef DUK__ALLOW_AUTO_SEMI_ALWAYS
-+
-+/*
-+ *  Parse a statement list.
-+ *
-+ *  Handles automatic semicolon insertion and implicit return value.
-+ *
-+ *  Upon entry, 'curr_tok' should contain the first token of the first
-+ *  statement (parsed in the "allow regexp literal" mode).  Upon exit,
-+ *  'curr_tok' contains the token following the statement list terminator
-+ *  (EOF or closing brace).
-+ */
-+
-+DUK_LOCAL void duk__parse_stmts(duk_compiler_ctx *comp_ctx, duk_bool_t allow_source_elem, duk_bool_t expect_eof) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_ivalue res_alloc;
-+	duk_ivalue *res = &res_alloc;
-+
-+	/* Setup state.  Initial ivalue is 'undefined'. */
-+
-+	duk_require_stack(ctx, DUK__PARSE_STATEMENTS_SLOTS);
-+
-+	/* XXX: 'res' setup can be moved to function body level; in fact, two 'res'
-+	 * intermediate values suffice for parsing of each function.  Nesting is needed
-+	 * for nested functions (which may occur inside expressions).
-+	 */
-+
-+	DUK_MEMZERO(&res_alloc, sizeof(res_alloc));
-+	res->t = DUK_IVAL_PLAIN;
-+	res->x1.t = DUK_ISPEC_VALUE;
-+	res->x1.valstack_idx = duk_get_top(ctx);
-+	res->x2.valstack_idx = res->x1.valstack_idx + 1;
-+	duk_push_undefined(ctx);
-+	duk_push_undefined(ctx);
-+
-+	/* Parse statements until a closing token (EOF or '}') is found. */
-+
-+	for (;;) {
-+		/* Check whether statement list ends. */
-+
-+		if (expect_eof) {
-+			if (comp_ctx->curr_token.t == DUK_TOK_EOF) {
-+				break;
-+			}
-+		} else {
-+			if (comp_ctx->curr_token.t == DUK_TOK_RCURLY) {
-+				break;
-+			}
-+		}
-+
-+		/* Check statement type based on the first token type.
-+		 *
-+		 * Note: expression parsing helpers expect 'curr_tok' to
-+		 * contain the first token of the expression upon entry.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("TOKEN %ld (non-whitespace, non-comment)", (long) comp_ctx->curr_token.t));
-+
-+		duk__parse_stmt(comp_ctx, res, allow_source_elem);
-+	}
-+
-+	duk__advance(comp_ctx);
-+
-+	/* Tear down state. */
-+
-+	duk_pop_2(ctx);
-+}
-+
-+/*
-+ *  Declaration binding instantiation conceptually happens when calling a
-+ *  function; for us it essentially means that function prologue.  The
-+ *  conceptual process is described in E5 Section 10.5.
-+ *
-+ *  We need to keep track of all encountered identifiers to (1) create an
-+ *  identifier-to-register map ("varmap"); and (2) detect duplicate
-+ *  declarations.  Identifiers which are not bound to registers still need
-+ *  to be tracked for detecting duplicates.  Currently such identifiers
-+ *  are put into the varmap with a 'null' value, which is later cleaned up.
-+ *
-+ *  To support functions with a large number of variable and function
-+ *  declarations, registers are not allocated beyond a certain limit;
-+ *  after that limit, variables and functions need slow path access.
-+ *  Arguments are currently always register bound, which imposes a hard
-+ *  (and relatively small) argument count limit.
-+ *
-+ *  Some bindings in E5 are not configurable (= deletable) and almost all
-+ *  are mutable (writable).  Exceptions are:
-+ *
-+ *    - The 'arguments' binding, established only if no shadowing argument
-+ *      or function declaration exists.  We handle 'arguments' creation
-+ *      and binding through an explicit slow path environment record.
-+ *
-+ *    - The "name" binding for a named function expression.  This is also
-+ *      handled through an explicit slow path environment record.
-+ */
-+
-+/* XXX: add support for variables to not be register bound always, to
-+ * handle cases with a very large number of variables?
-+ */
-+
-+DUK_LOCAL void duk__init_varmap_and_prologue_for_pass2(duk_compiler_ctx *comp_ctx, duk_reg_t *out_stmt_value_reg) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *h_name;
-+	duk_bool_t configurable_bindings;
-+	duk_uarridx_t num_args;
-+	duk_uarridx_t num_decls;
-+	duk_regconst_t rc_name;
-+	duk_small_uint_t declvar_flags;
-+	duk_uarridx_t i;
-+#ifdef DUK_USE_ASSERTIONS
-+	duk_idx_t entry_top;
-+#endif
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	entry_top = duk_get_top(ctx);
-+#endif
-+
-+	/*
-+	 *  Preliminaries
-+	 */
-+
-+	configurable_bindings = comp_ctx->curr_func.is_eval;
-+	DUK_DDD(DUK_DDDPRINT("configurable_bindings=%ld", (long) configurable_bindings));
-+
-+	/* varmap is already in comp_ctx->curr_func.varmap_idx */
-+
-+	/*
-+	 *  Function formal arguments, always bound to registers
-+	 *  (there's no support for shuffling them now).
-+	 */
-+
-+	num_args = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.argnames_idx);
-+	DUK_DDD(DUK_DDDPRINT("num_args=%ld", (long) num_args));
-+	/* XXX: check num_args */
-+
-+	for (i = 0; i < num_args; i++) {
-+		duk_get_prop_index(ctx, comp_ctx->curr_func.argnames_idx, i);
-+		h_name = duk_get_hstring(ctx, -1);
-+		DUK_ASSERT(h_name != NULL);
-+
-+		if (comp_ctx->curr_func.is_strict) {
-+			if (duk__hstring_is_eval_or_arguments(comp_ctx, h_name)) {
-+				DUK_DDD(DUK_DDDPRINT("arg named 'eval' or 'arguments' in strict mode -> SyntaxError"));
-+				goto error_argname;
-+			}
-+			duk_dup_top(ctx);
-+			if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
-+				DUK_DDD(DUK_DDDPRINT("duplicate arg name in strict mode -> SyntaxError"));
-+				goto error_argname;
-+			}
-+
-+			/* Ensure argument name is not a reserved word in current
-+			 * (final) strictness.  Formal argument parsing may not
-+			 * catch reserved names if strictness changes during
-+			 * parsing.
-+			 *
-+			 * We only need to do this in strict mode because non-strict
-+			 * keyword are always detected in formal argument parsing.
-+			 */
-+
-+			if (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(h_name)) {
-+				goto error_argname;
-+			}
-+		}
-+
-+		/* overwrite any previous binding of the same name; the effect is
-+		 * that last argument of a certain name wins.
-+		 */
-+
-+		/* only functions can have arguments */
-+		DUK_ASSERT(comp_ctx->curr_func.is_function);
-+		duk_push_uarridx(ctx, i);  /* -> [ ... name index ] */
-+		duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx); /* -> [ ... ] */
-+
-+		/* no code needs to be emitted, the regs already have values */
-+	}
-+
-+	/* use temp_next for tracking register allocations */
-+	DUK__SETTEMP_CHECKMAX(comp_ctx, (duk_reg_t) num_args);
-+
-+	/*
-+	 *  After arguments, allocate special registers (like shuffling temps)
-+	 */
-+
-+	if (out_stmt_value_reg) {
-+		*out_stmt_value_reg = DUK__ALLOCTEMP(comp_ctx);
-+	}
-+	if (comp_ctx->curr_func.needs_shuffle) {
-+		duk_reg_t shuffle_base = DUK__ALLOCTEMPS(comp_ctx, 3);
-+		comp_ctx->curr_func.shuffle1 = shuffle_base;
-+		comp_ctx->curr_func.shuffle2 = shuffle_base + 1;
-+		comp_ctx->curr_func.shuffle3 = shuffle_base + 2;
-+		DUK_D(DUK_DPRINT("shuffle registers needed by function, allocated: %ld %ld %ld",
-+		                 (long) comp_ctx->curr_func.shuffle1,
-+		                 (long) comp_ctx->curr_func.shuffle2,
-+		                 (long) comp_ctx->curr_func.shuffle3));
-+	}
-+	if (comp_ctx->curr_func.temp_next > 0x100) {
-+		DUK_D(DUK_DPRINT("not enough 8-bit regs: temp_next=%ld", (long) comp_ctx->curr_func.temp_next));
-+		goto error_outofregs;
-+	}
-+
-+	/*
-+	 *  Function declarations
-+	 */
-+
-+	num_decls = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.decls_idx);
-+	DUK_DDD(DUK_DDDPRINT("num_decls=%ld -> %!T",
-+	                     (long) num_decls,
-+	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.decls_idx)));
-+	for (i = 0; i < num_decls; i += 2) {
-+		duk_int_t decl_type;
-+		duk_int_t fnum;
-+
-+		duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i + 1);  /* decl type */
-+		decl_type = duk_to_int(ctx, -1);
-+		fnum = decl_type >> 8;  /* XXX: macros */
-+		decl_type = decl_type & 0xff;
-+		duk_pop(ctx);
-+
-+		if (decl_type != DUK_DECL_TYPE_FUNC) {
-+			continue;
-+		}
-+
-+		duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i);  /* decl name */
-+
-+		/* XXX: spilling */
-+		if (comp_ctx->curr_func.is_function) {
-+			duk_reg_t reg_bind;
-+			duk_dup_top(ctx);
-+			if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
-+				/* shadowed; update value */
-+				duk_dup_top(ctx);
-+				duk_get_prop(ctx, comp_ctx->curr_func.varmap_idx);
-+				reg_bind = duk_to_int(ctx, -1);  /* [ ... name reg_bind ] */
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_CLOSURE,
-+				               (duk_regconst_t) reg_bind,
-+				               (duk_regconst_t) fnum);
-+			} else {
-+				/* function: always register bound */
-+				reg_bind = DUK__ALLOCTEMP(comp_ctx);
-+				duk__emit_a_bc(comp_ctx,
-+				               DUK_OP_CLOSURE,
-+				               (duk_regconst_t) reg_bind,
-+				               (duk_regconst_t) fnum);
-+				duk_push_int(ctx, (duk_int_t) reg_bind);
-+			}
-+		} else {
-+			/* Function declaration for global/eval code is emitted even
-+			 * for duplicates, because of E5 Section 10.5, step 5.e of
-+			 * E5.1 (special behavior for variable bound to global object).
-+			 *
-+			 * DECLVAR will not re-declare a variable as such, but will
-+			 * update the binding value.
-+			 */
-+
-+			duk_reg_t reg_temp = DUK__ALLOCTEMP(comp_ctx);
-+			duk_dup_top(ctx);
-+			rc_name = duk__getconst(comp_ctx);
-+			duk_push_null(ctx);
-+
-+			duk__emit_a_bc(comp_ctx,
-+			               DUK_OP_CLOSURE,
-+			               (duk_regconst_t) reg_temp,
-+			               (duk_regconst_t) fnum);
-+
-+			declvar_flags = DUK_PROPDESC_FLAG_WRITABLE |
-+			                DUK_PROPDESC_FLAG_ENUMERABLE |
-+			                DUK_BC_DECLVAR_FLAG_FUNC_DECL;
-+
-+			if (configurable_bindings) {
-+				declvar_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
-+			}
-+
-+			duk__emit_a_b_c(comp_ctx,
-+			                DUK_OP_DECLVAR | DUK__EMIT_FLAG_NO_SHUFFLE_A,
-+			                (duk_regconst_t) declvar_flags /*flags*/,
-+			                rc_name /*name*/,
-+			                (duk_regconst_t) reg_temp /*value*/);
-+
-+			DUK__SETTEMP(comp_ctx, reg_temp);  /* forget temp */
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("function declaration to varmap: %!T -> %!T",
-+		                     (duk_tval *) duk_get_tval(ctx, -2),
-+		                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+		duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);  /* [ ... name reg/null ] -> [ ... ] */
-+	}
-+
-+	/*
-+	 *  'arguments' binding is special; if a shadowing argument or
-+	 *  function declaration exists, an arguments object will
-+	 *  definitely not be needed, regardless of whether the identifier
-+	 *  'arguments' is referenced inside the function body.
-+	 */
-+
-+	if (duk_has_prop_stridx(ctx, comp_ctx->curr_func.varmap_idx, DUK_STRIDX_LC_ARGUMENTS)) {
-+		DUK_DDD(DUK_DDDPRINT("'arguments' is shadowed by argument or function declaration "
-+		                     "-> arguments object creation can be skipped"));
-+		comp_ctx->curr_func.is_arguments_shadowed = 1;
-+	}
-+
-+	/*
-+	 *  Variable declarations.
-+	 *
-+	 *  Unlike function declarations, variable declaration values don't get
-+	 *  assigned on entry.  If a binding of the same name already exists, just
-+	 *  ignore it silently.
-+	 */
-+
-+	for (i = 0; i < num_decls; i += 2) {
-+		duk_int_t decl_type;
-+
-+		duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i + 1);  /* decl type */
-+		decl_type = duk_to_int(ctx, -1);
-+		decl_type = decl_type & 0xff;
-+		duk_pop(ctx);
-+
-+		if (decl_type != DUK_DECL_TYPE_VAR) {
-+			continue;
-+		}
-+
-+		duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i);  /* decl name */
-+
-+		if (duk_has_prop(ctx, comp_ctx->curr_func.varmap_idx)) {
-+			/* shadowed, ignore */
-+		} else {
-+			duk_get_prop_index(ctx, comp_ctx->curr_func.decls_idx, i);  /* decl name */
-+			h_name = duk_get_hstring(ctx, -1);
-+			DUK_ASSERT(h_name != NULL);
-+
-+			if (h_name == DUK_HTHREAD_STRING_LC_ARGUMENTS(thr) &&
-+			    !comp_ctx->curr_func.is_arguments_shadowed) {
-+				/* E5 Section steps 7-8 */
-+				DUK_DDD(DUK_DDDPRINT("'arguments' not shadowed by a function declaration, "
-+				                     "but appears as a variable declaration -> treat as "
-+				                     "a no-op for variable declaration purposes"));
-+				duk_pop(ctx);
-+				continue;
-+			}
-+
-+			/* XXX: spilling */
-+			if (comp_ctx->curr_func.is_function) {
-+				duk_reg_t reg_bind = DUK__ALLOCTEMP(comp_ctx);
-+				/* no need to init reg, it will be undefined on entry */
-+				duk_push_int(ctx, (duk_int_t) reg_bind);
-+			} else {
-+				duk_dup_top(ctx);
-+				rc_name = duk__getconst(comp_ctx);
-+				duk_push_null(ctx);
-+
-+				declvar_flags = DUK_PROPDESC_FLAG_WRITABLE |
-+			                        DUK_PROPDESC_FLAG_ENUMERABLE |
-+				                DUK_BC_DECLVAR_FLAG_UNDEF_VALUE;
-+				if (configurable_bindings) {
-+					declvar_flags |= DUK_PROPDESC_FLAG_CONFIGURABLE;
-+				}
-+
-+				duk__emit_a_b_c(comp_ctx,
-+				                DUK_OP_DECLVAR | DUK__EMIT_FLAG_NO_SHUFFLE_A,
-+				                (duk_regconst_t) declvar_flags /*flags*/,
-+				                rc_name /*name*/,
-+				                (duk_regconst_t) 0 /*value*/);
-+			}
-+
-+			duk_put_prop(ctx, comp_ctx->curr_func.varmap_idx);  /* [ ... name reg/null ] -> [ ... ] */
-+		}
-+	}
-+
-+	/*
-+	 *  Wrap up
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("varmap: %!T, is_arguments_shadowed=%ld",
-+	                     (duk_tval *) duk_get_tval(ctx, comp_ctx->curr_func.varmap_idx),
-+	                     (long) comp_ctx->curr_func.is_arguments_shadowed));
-+
-+	DUK_ASSERT_TOP(ctx, entry_top);
-+	return;
-+
-+ error_outofregs:
-+	DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, DUK_STR_REG_LIMIT);
-+	DUK_UNREACHABLE();
-+	return;
-+
-+ error_argname:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_ARG_NAME);
-+	DUK_UNREACHABLE();
-+	return;
-+}
-+
-+/*
-+ *  Parse a function-body-like expression (FunctionBody or Program
-+ *  in E5 grammar) using a two-pass parse.  The productions appear
-+ *  in the following contexts:
-+ *
-+ *    - function expression
-+ *    - function statement
-+ *    - function declaration
-+ *    - getter in object literal
-+ *    - setter in object literal
-+ *    - global code
-+ *    - eval code
-+ *    - Function constructor body
-+ *
-+ *  This function only parses the statement list of the body; the argument
-+ *  list and possible function name must be initialized by the caller.
-+ *  For instance, for Function constructor, the argument names are originally
-+ *  on the value stack.  The parsing of statements ends either at an EOF or
-+ *  a closing brace; this is controlled by an input flag.
-+ *
-+ *  Note that there are many differences affecting parsing and even code
-+ *  generation:
-+ *
-+ *    - Global and eval code have an implicit return value generated
-+ *      by the last statement; function code does not
-+ *
-+ *    - Global code, eval code, and Function constructor body end in
-+ *      an EOF, other bodies in a closing brace ('}')
-+ *
-+ *  Upon entry, 'curr_tok' is ignored and the function will pull in the
-+ *  first token on its own.  Upon exit, 'curr_tok' is the terminating
-+ *  token (EOF or closing brace).
-+ */
-+
-+DUK_LOCAL void duk__parse_func_body(duk_compiler_ctx *comp_ctx, duk_bool_t expect_eof, duk_bool_t implicit_return_value, duk_small_int_t expect_token) {
-+	duk_compiler_func *func;
-+	duk_hthread *thr;
-+	duk_context *ctx;
-+	duk_reg_t reg_stmt_value = -1;
-+	duk_lexer_point lex_pt;
-+	duk_reg_t temp_first;
-+	duk_small_int_t compile_round = 1;
-+
-+	DUK_ASSERT(comp_ctx != NULL);
-+
-+	thr = comp_ctx->thr;
-+	ctx = (duk_context *) thr;
-+	DUK_ASSERT(thr != NULL);
-+
-+	func = &comp_ctx->curr_func;
-+	DUK_ASSERT(func != NULL);
-+
-+	DUK__RECURSION_INCREASE(comp_ctx, thr);
-+
-+	duk_require_stack(ctx, DUK__FUNCTION_BODY_REQUIRE_SLOTS);
-+
-+	/*
-+	 *  Store lexer position for a later rewind
-+	 */
-+
-+	DUK_LEXER_GETPOINT(&comp_ctx->lex, &lex_pt);
-+
-+	/*
-+	 *  Program code (global and eval code) has an implicit return value
-+	 *  from the last statement value (e.g. eval("1; 2+3;") returns 3).
-+	 *  This is not the case with functions.  If implicit statement return
-+	 *  value is requested, all statements are coerced to a register
-+	 *  allocated here, and used in the implicit return statement below.
-+	 */
-+
-+	/* XXX: this is pointless here because pass 1 is throw-away */
-+	if (implicit_return_value) {
-+		reg_stmt_value = DUK__ALLOCTEMP(comp_ctx);
-+
-+		/* If an implicit return value is needed by caller, it must be
-+		 * initialized to 'undefined' because we don't know whether any
-+		 * non-empty (where "empty" is a continuation type, and different
-+		 * from an empty statement) statements will be executed.
-+		 *
-+		 * However, since 1st pass is a throwaway one, no need to emit
-+		 * it here.
-+		 */
-+#if 0
-+		duk__emit_extraop_bc(comp_ctx,
-+		                     DUK_EXTRAOP_LDUNDEF,
-+		                     0);
-+#endif
-+	}
-+
-+	/*
-+	 *  First pass.
-+	 *
-+	 *  Gather variable/function declarations needed for second pass.
-+	 *  Code generated is dummy and discarded.
-+	 */
-+
-+	func->in_directive_prologue = 1;
-+	func->in_scanning = 1;
-+	func->may_direct_eval = 0;
-+	func->id_access_arguments = 0;
-+	func->id_access_slow = 0;
-+	func->reg_stmt_value = reg_stmt_value;
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	func->min_line = DUK_INT_MAX;
-+	func->max_line = 0;
-+#endif
-+
-+	/* duk__parse_stmts() expects curr_tok to be set; parse in "allow regexp literal" mode with current strictness */
-+	if (expect_token >= 0) {
-+		/* Eating a left curly; regexp mode is allowed by left curly
-+		 * based on duk__token_lbp[] automatically.
-+		 */
-+		DUK_ASSERT(expect_token == DUK_TOK_LCURLY);
-+		duk__update_lineinfo_currtoken(comp_ctx);
-+		duk__advance_expect(comp_ctx, expect_token);
-+	} else {
-+		/* Need to set curr_token.t because lexing regexp mode depends on current
-+		 * token type.  Zero value causes "allow regexp" mode.
-+		 */
-+		comp_ctx->curr_token.t = 0;
-+		duk__advance(comp_ctx);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("begin 1st pass"));
-+	duk__parse_stmts(comp_ctx,
-+	                 1,             /* allow source elements */
-+	                 expect_eof);   /* expect EOF instead of } */
-+	DUK_DDD(DUK_DDDPRINT("end 1st pass"));
-+
-+	/*
-+	 *  Second (and possibly third) pass.
-+	 *
-+	 *  Generate actual code.  In most cases the need for shuffle
-+	 *  registers is detected during pass 1, but in some corner cases
-+	 *  we'll only detect it during pass 2 and a third pass is then
-+	 *  needed (see GH-115).
-+	 */
-+
-+	for (;;) {
-+		duk_bool_t needs_shuffle_before = comp_ctx->curr_func.needs_shuffle;
-+		compile_round++;
-+
-+		/*
-+		 *  Rewind lexer.
-+		 *
-+		 *  duk__parse_stmts() expects curr_tok to be set; parse in "allow regexp
-+		 *  literal" mode with current strictness.
-+		 *
-+		 *  curr_token line number info should be initialized for pass 2 before
-+		 *  generating prologue, to ensure prologue bytecode gets nice line numbers.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("rewind lexer"));
-+		DUK_LEXER_SETPOINT(&comp_ctx->lex, &lex_pt);
-+		comp_ctx->curr_token.t = 0;  /* this is needed for regexp mode */
-+		comp_ctx->curr_token.start_line = 0;  /* needed for line number tracking (becomes prev_token.start_line) */
-+		duk__advance(comp_ctx);
-+
-+		/*
-+		 *  Reset function state and perform register allocation, which creates
-+		 *  'varmap' for second pass.  Function prologue for variable declarations,
-+		 *  binding value initializations etc is emitted as a by-product.
-+		 *
-+		 *  Strict mode restrictions for duplicate and invalid argument
-+		 *  names are checked here now that we know whether the function
-+		 *  is actually strict.  See: test-dev-strict-mode-boundary.js.
-+		 *
-+		 *  Inner functions are compiled during pass 1 and are not reset.
-+		 */
-+
-+		duk__reset_func_for_pass2(comp_ctx);
-+		func->in_directive_prologue = 1;
-+		func->in_scanning = 0;
-+
-+		/* must be able to emit code, alloc consts, etc. */
-+
-+		duk__init_varmap_and_prologue_for_pass2(comp_ctx,
-+		                                        (implicit_return_value ? &reg_stmt_value : NULL));
-+		func->reg_stmt_value = reg_stmt_value;
-+
-+		temp_first = DUK__GETTEMP(comp_ctx);
-+
-+		func->temp_first = temp_first;
-+		func->temp_next = temp_first;
-+		func->stmt_next = 0;
-+		func->label_next = 0;
-+
-+		/* XXX: init or assert catch depth etc -- all values */
-+		func->id_access_arguments = 0;
-+		func->id_access_slow = 0;
-+
-+		/*
-+		 *  Check function name validity now that we know strictness.
-+		 *  This only applies to function declarations and expressions,
-+		 *  not setter/getter name.
-+		 *
-+		 *  See: test-dev-strict-mode-boundary.js
-+		 */
-+
-+		if (func->is_function && !func->is_setget && func->h_name != NULL) {
-+			if (func->is_strict) {
-+				if (duk__hstring_is_eval_or_arguments(comp_ctx, func->h_name)) {
-+					DUK_DDD(DUK_DDDPRINT("func name is 'eval' or 'arguments' in strict mode"));
-+					goto error_funcname;
-+				}
-+				if (DUK_HSTRING_HAS_STRICT_RESERVED_WORD(func->h_name)) {
-+					DUK_DDD(DUK_DDDPRINT("func name is a reserved word in strict mode"));
-+					goto error_funcname;
-+				}
-+			} else {
-+				if (DUK_HSTRING_HAS_RESERVED_WORD(func->h_name) &&
-+				    !DUK_HSTRING_HAS_STRICT_RESERVED_WORD(func->h_name)) {
-+					DUK_DDD(DUK_DDDPRINT("func name is a reserved word in non-strict mode"));
-+					goto error_funcname;
-+				}
-+			}
-+		}
-+
-+		/*
-+		 *  Second pass parsing.
-+		 */
-+
-+		if (implicit_return_value) {
-+			/* Default implicit return value. */
-+			duk__emit_extraop_bc(comp_ctx,
-+			                     DUK_EXTRAOP_LDUNDEF,
-+			                     0);
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("begin 2nd pass"));
-+		duk__parse_stmts(comp_ctx,
-+		                 1,             /* allow source elements */
-+		                 expect_eof);   /* expect EOF instead of } */
-+		DUK_DDD(DUK_DDDPRINT("end 2nd pass"));
-+
-+		duk__update_lineinfo_currtoken(comp_ctx);
-+
-+		if (needs_shuffle_before == comp_ctx->curr_func.needs_shuffle) {
-+			/* Shuffle decision not changed. */
-+			break;
-+		}
-+		if (compile_round >= 3) {
-+			/* Should never happen but avoid infinite loop just in case. */
-+			DUK_D(DUK_DPRINT("more than 3 compile passes needed, should never happen"));
-+			DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR);
-+		}
-+		DUK_D(DUK_DPRINT("need additional round to compile function, round now %d", (int) compile_round));
-+	}
-+
-+	/*
-+	 *  Emit a final RETURN.
-+	 *
-+	 *  It would be nice to avoid emitting an unnecessary "return" opcode
-+	 *  if the current PC is not reachable.  However, this cannot be reliably
-+	 *  detected; even if the previous instruction is an unconditional jump,
-+	 *  there may be a previous jump which jumps to current PC (which is the
-+	 *  case for iteration and conditional statements, for instance).
-+	 */
-+
-+	/* XXX: request a "last statement is terminal" from duk__parse_stmt() and duk__parse_stmts();
-+	 * we could avoid the last RETURN if we could ensure there is no way to get here
-+	 * (directly or via a jump)
-+	 */
-+
-+	DUK_ASSERT(comp_ctx->curr_func.catch_depth == 0);  /* fast returns are always OK here */
-+	if (reg_stmt_value >= 0) {
-+		duk__emit_a_b(comp_ctx,
-+		              DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A,
-+		              (duk_regconst_t) (DUK_BC_RETURN_FLAG_HAVE_RETVAL | DUK_BC_RETURN_FLAG_FAST) /*flags*/,
-+		              (duk_regconst_t) reg_stmt_value /*reg*/);
-+	} else {
-+		duk__emit_a_b(comp_ctx,
-+		              DUK_OP_RETURN | DUK__EMIT_FLAG_NO_SHUFFLE_A,
-+		              (duk_regconst_t) DUK_BC_RETURN_FLAG_FAST /*flags*/,
-+		              (duk_regconst_t) 0 /*reg(ignored)*/);
-+	}
-+
-+	/*
-+	 *  Peephole optimize JUMP chains.
-+	 */
-+
-+	duk__peephole_optimize_bytecode(comp_ctx);
-+
-+	/*
-+	 *  comp_ctx->curr_func is now ready to be converted into an actual
-+	 *  function template.
-+	 */
-+
-+	DUK__RECURSION_DECREASE(comp_ctx, thr);
-+	return;
-+
-+ error_funcname:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_FUNC_NAME);
-+}
-+
-+/*
-+ *  Parse a function-like expression:
-+ *
-+ *    - function expression
-+ *    - function declaration
-+ *    - function statement (non-standard)
-+ *    - setter/getter
-+ *
-+ *  Adds the function to comp_ctx->curr_func function table and returns the
-+ *  function number.
-+ *
-+ *  On entry, curr_token points to:
-+ *
-+ *    - the token after 'function' for function expression/declaration/statement
-+ *    - the token after 'set' or 'get' for setter/getter
-+ */
-+
-+/* Parse formals. */
-+DUK_LOCAL void duk__parse_func_formals(duk_compiler_ctx *comp_ctx) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_bool_t first = 1;
-+	duk_uarridx_t n;
-+
-+	for (;;) {
-+		if (comp_ctx->curr_token.t == DUK_TOK_RPAREN) {
-+			break;
-+		}
-+
-+		if (first) {
-+			/* no comma */
-+			first = 0;
-+		} else {
-+			duk__advance_expect(comp_ctx, DUK_TOK_COMMA);
-+		}
-+
-+		/* Note: when parsing a formal list in non-strict context, e.g.
-+		 * "implements" is parsed as an identifier.  When the function is
-+		 * later detected to be strict, the argument list must be rechecked
-+		 * against a larger set of reserved words (that of strict mode).
-+		 * This is handled by duk__parse_func_body().  Here we recognize
-+		 * whatever tokens are considered reserved in current strictness
-+		 * (which is not always enough).
-+		 */
-+
-+		if (comp_ctx->curr_token.t != DUK_TOK_IDENTIFIER) {
-+			DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, "expected identifier");
-+		}
-+		DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_IDENTIFIER);
-+		DUK_ASSERT(comp_ctx->curr_token.str1 != NULL);
-+		DUK_DDD(DUK_DDDPRINT("formal argument: %!O",
-+		                     (duk_heaphdr *) comp_ctx->curr_token.str1));
-+
-+		/* XXX: append primitive */
-+		duk_push_hstring(ctx, comp_ctx->curr_token.str1);
-+		n = (duk_uarridx_t) duk_get_length(ctx, comp_ctx->curr_func.argnames_idx);
-+		duk_put_prop_index(ctx, comp_ctx->curr_func.argnames_idx, n);
-+
-+		duk__advance(comp_ctx);  /* eat identifier */
-+	}
-+}
-+
-+/* Parse a function-like expression, assuming that 'comp_ctx->curr_func' is
-+ * correctly set up.  Assumes that curr_token is just after 'function' (or
-+ * 'set'/'get' etc).
-+ */
-+DUK_LOCAL void duk__parse_func_like_raw(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+
-+	DUK_ASSERT(comp_ctx->curr_func.num_formals == 0);
-+	DUK_ASSERT(comp_ctx->curr_func.is_function == 1);
-+	DUK_ASSERT(comp_ctx->curr_func.is_eval == 0);
-+	DUK_ASSERT(comp_ctx->curr_func.is_global == 0);
-+	DUK_ASSERT(comp_ctx->curr_func.is_setget == is_setget);
-+	DUK_ASSERT(comp_ctx->curr_func.is_decl == is_decl);
-+
-+	duk__update_lineinfo_currtoken(comp_ctx);
-+
-+	/*
-+	 *  Function name (if any)
-+	 *
-+	 *  We don't check for prohibited names here, because we don't
-+	 *  yet know whether the function will be strict.  Function body
-+	 *  parsing handles this retroactively.
-+	 *
-+	 *  For function expressions and declarations function name must
-+	 *  be an Identifer (excludes reserved words).  For setter/getter
-+	 *  it is a PropertyName which allows reserved words and also
-+	 *  strings and numbers (e.g. "{ get 1() { ... } }").
-+	 */
-+
-+	if (is_setget) {
-+		/* PropertyName -> IdentifierName | StringLiteral | NumericLiteral */
-+		if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER ||
-+		    comp_ctx->curr_token.t == DUK_TOK_STRING) {
-+			duk_push_hstring(ctx, comp_ctx->curr_token.str1);       /* keep in valstack */
-+		} else if (comp_ctx->curr_token.t == DUK_TOK_NUMBER) {
-+			duk_push_number(ctx, comp_ctx->curr_token.num);
-+			duk_to_string(ctx, -1);
-+		} else {
-+			DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_GETSET_NAME);
-+		}
-+		comp_ctx->curr_func.h_name = duk_get_hstring(ctx, -1);  /* borrowed reference */
-+		DUK_ASSERT(comp_ctx->curr_func.h_name != NULL);
-+		duk__advance(comp_ctx);
-+	} else {
-+		/* Function name is an Identifier (not IdentifierName), but we get
-+		 * the raw name (not recognizing keywords) here and perform the name
-+		 * checks only after pass 1.
-+		 */
-+		if (comp_ctx->curr_token.t_nores == DUK_TOK_IDENTIFIER) {
-+			duk_push_hstring(ctx, comp_ctx->curr_token.str1);       /* keep in valstack */
-+			comp_ctx->curr_func.h_name = duk_get_hstring(ctx, -1);  /* borrowed reference */
-+			DUK_ASSERT(comp_ctx->curr_func.h_name != NULL);
-+			duk__advance(comp_ctx);
-+		} else {
-+			/* valstack will be unbalanced, which is OK */
-+			DUK_ASSERT(!is_setget);
-+			if (is_decl) {
-+				DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_FUNC_NAME_REQUIRED);
-+			}
-+		}
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("function name: %!O",
-+	                     (duk_heaphdr *) comp_ctx->curr_func.h_name));
-+
-+	/*
-+	 *  Formal argument list
-+	 *
-+	 *  We don't check for prohibited names or for duplicate argument
-+	 *  names here, becase we don't yet know whether the function will
-+	 *  be strict.  Function body parsing handles this retroactively.
-+	 */
-+
-+	duk__advance_expect(comp_ctx, DUK_TOK_LPAREN);
-+
-+	duk__parse_func_formals(comp_ctx);
-+
-+	DUK_ASSERT(comp_ctx->curr_token.t == DUK_TOK_RPAREN);
-+	duk__advance(comp_ctx);
-+
-+	/*
-+	 *  Parse function body
-+	 */
-+
-+	duk__parse_func_body(comp_ctx,
-+	                     0,   /* expect_eof */
-+	                     0,   /* implicit_return_value */
-+	                     DUK_TOK_LCURLY);  /* expect_token */
-+
-+	/*
-+	 *  Convert duk_compiler_func to a function template and add it
-+	 *  to the parent function table.
-+	 */
-+
-+	duk__convert_to_func_template(comp_ctx, is_setget /*force_no_namebind*/);  /* -> [ ... func ] */
-+}
-+
-+/* Parse an inner function, adding the function template to the current function's
-+ * function table.  Return a function number to be used by the outer function.
-+ *
-+ * Avoiding O(depth^2) inner function parsing is handled here.  On the first pass,
-+ * compile and register the function normally into the 'funcs' array, also recording
-+ * a lexer point (offset/line) to the closing brace of the function.  On the second
-+ * pass, skip the function and return the same 'fnum' as on the first pass by using
-+ * a running counter.
-+ *
-+ * An unfortunate side effect of this is that when parsing the inner function, almost
-+ * nothing is known of the outer function, i.e. the inner function's scope.  We don't
-+ * need that information at the moment, but it would allow some optimizations if it
-+ * were used.
-+ */
-+DUK_LOCAL duk_int_t duk__parse_func_like_fnum(duk_compiler_ctx *comp_ctx, duk_bool_t is_decl, duk_bool_t is_setget) {
-+	duk_hthread *thr = comp_ctx->thr;
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_compiler_func old_func;
-+	duk_idx_t entry_top;
-+	duk_int_t fnum;
-+
-+	/*
-+	 *  On second pass, skip the function.
-+	 */
-+
-+	if (!comp_ctx->curr_func.in_scanning) {
-+		duk_lexer_point lex_pt;
-+
-+		fnum = comp_ctx->curr_func.fnum_next++;
-+		duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 1));
-+		lex_pt.offset = duk_to_int(ctx, -1);
-+		duk_pop(ctx);
-+		duk_get_prop_index(ctx, comp_ctx->curr_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 2));
-+		lex_pt.line = duk_to_int(ctx, -1);
-+		duk_pop(ctx);
-+
-+		DUK_DDD(DUK_DDDPRINT("second pass of an inner func, skip the function, reparse closing brace; lex offset=%ld, line=%ld",
-+		                     (long) lex_pt.offset, (long) lex_pt.line));
-+
-+		DUK_LEXER_SETPOINT(&comp_ctx->lex, &lex_pt);
-+		comp_ctx->curr_token.t = 0;  /* this is needed for regexp mode */
-+		comp_ctx->curr_token.start_line = 0;  /* needed for line number tracking (becomes prev_token.start_line) */
-+		duk__advance(comp_ctx);
-+		duk__advance_expect(comp_ctx, DUK_TOK_RCURLY);
-+
-+		return fnum;
-+	}
-+
-+	/*
-+	 *  On first pass, perform actual parsing.  Remember valstack top on entry
-+	 *  to restore it later, and switch to using a new function in comp_ctx.
-+	 */
-+
-+	entry_top = duk_get_top(ctx);
-+	DUK_DDD(DUK_DDDPRINT("before func: entry_top=%ld, curr_tok.start_offset=%ld",
-+	                     (long) entry_top, (long) comp_ctx->curr_token.start_offset));
-+
-+	DUK_MEMCPY(&old_func, &comp_ctx->curr_func, sizeof(duk_compiler_func));
-+
-+	DUK_MEMZERO(&comp_ctx->curr_func, sizeof(duk_compiler_func));
-+	duk__init_func_valstack_slots(comp_ctx);
-+	DUK_ASSERT(comp_ctx->curr_func.num_formals == 0);
-+
-+	/* inherit initial strictness from parent */
-+	comp_ctx->curr_func.is_strict = old_func.is_strict;
-+
-+	DUK_ASSERT(comp_ctx->curr_func.is_notail == 0);
-+	comp_ctx->curr_func.is_function = 1;
-+	DUK_ASSERT(comp_ctx->curr_func.is_eval == 0);
-+	DUK_ASSERT(comp_ctx->curr_func.is_global == 0);
-+	comp_ctx->curr_func.is_setget = is_setget;
-+	comp_ctx->curr_func.is_decl = is_decl;
-+
-+	/*
-+	 *  Parse inner function
-+	 */
-+
-+	duk__parse_func_like_raw(comp_ctx, is_decl, is_setget);  /* pushes function template */
-+
-+	/* prev_token.start_offset points to the closing brace here; when skipping
-+	 * we're going to reparse the closing brace to ensure semicolon insertion
-+	 * etc work as expected.
-+	 */
-+	DUK_DDD(DUK_DDDPRINT("after func: prev_tok.start_offset=%ld, curr_tok.start_offset=%ld",
-+	                     (long) comp_ctx->prev_token.start_offset, (long) comp_ctx->curr_token.start_offset));
-+	DUK_ASSERT(comp_ctx->lex.input[comp_ctx->prev_token.start_offset] == (duk_uint8_t) DUK_ASC_RCURLY);
-+
-+	/* XXX: append primitive */
-+	DUK_ASSERT(duk_get_length(ctx, old_func.funcs_idx) == (duk_size_t) (old_func.fnum_next * 3));
-+	fnum = old_func.fnum_next++;
-+
-+	if (fnum > DUK__MAX_FUNCS) {
-+		DUK_ERROR(comp_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_FUNC_LIMIT);
-+	}
-+
-+	/* array writes autoincrement length */
-+	(void) duk_put_prop_index(ctx, old_func.funcs_idx, (duk_uarridx_t) (fnum * 3));
-+	duk_push_size_t(ctx, comp_ctx->prev_token.start_offset);
-+	(void) duk_put_prop_index(ctx, old_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 1));
-+	duk_push_int(ctx, comp_ctx->prev_token.start_line);
-+	(void) duk_put_prop_index(ctx, old_func.funcs_idx, (duk_uarridx_t) (fnum * 3 + 2));
-+
-+	/*
-+	 *  Cleanup: restore original function, restore valstack state.
-+	 */
-+
-+	DUK_MEMCPY((void *) &comp_ctx->curr_func, (void *) &old_func, sizeof(duk_compiler_func));
-+	duk_set_top(ctx, entry_top);
-+
-+	DUK_ASSERT_TOP(ctx, entry_top);
-+
-+	return fnum;
-+}
-+
-+/*
-+ *  Compile input string into an executable function template without
-+ *  arguments.
-+ *
-+ *  The string is parsed as the "Program" production of Ecmascript E5.
-+ *  Compilation context can be either global code or eval code (see E5
-+ *  Sections 14 and 15.1.2.1).
-+ *
-+ *  Input stack:  [ ... filename ]
-+ *  Output stack: [ ... func_template ]
-+ */
-+
-+/* XXX: source code property */
-+
-+DUK_LOCAL duk_ret_t duk__js_compile_raw(duk_context *ctx) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk_hstring *h_filename;
-+	duk__compiler_stkstate *comp_stk;
-+	duk_compiler_ctx *comp_ctx;
-+	duk_lexer_point *lex_pt;
-+	duk_compiler_func *func;
-+	duk_idx_t entry_top;
-+	duk_bool_t is_strict;
-+	duk_bool_t is_eval;
-+	duk_bool_t is_funcexpr;
-+	duk_small_uint_t flags;
-+
-+	DUK_ASSERT(thr != NULL);
-+
-+	/*
-+	 *  Arguments check
-+	 */
-+
-+	entry_top = duk_get_top(ctx);
-+	DUK_ASSERT(entry_top >= 2);
-+
-+	comp_stk = (duk__compiler_stkstate *) duk_require_pointer(ctx, -1);
-+	comp_ctx = &comp_stk->comp_ctx_alloc;
-+	lex_pt = &comp_stk->lex_pt_alloc;
-+	DUK_ASSERT(comp_ctx != NULL);
-+	DUK_ASSERT(lex_pt != NULL);
-+
-+	flags = comp_stk->flags;
-+	is_eval = (flags & DUK_JS_COMPILE_FLAG_EVAL ? 1 : 0);
-+	is_strict = (flags & DUK_JS_COMPILE_FLAG_STRICT ? 1 : 0);
-+	is_funcexpr = (flags & DUK_JS_COMPILE_FLAG_FUNCEXPR ? 1 : 0);
-+
-+	h_filename = duk_get_hstring(ctx, -2);  /* may be undefined */
-+
-+	/*
-+	 *  Init compiler and lexer contexts
-+	 */
-+
-+	func = &comp_ctx->curr_func;
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	comp_ctx->thr = NULL;
-+	comp_ctx->h_filename = NULL;
-+	comp_ctx->prev_token.str1 = NULL;
-+	comp_ctx->prev_token.str2 = NULL;
-+	comp_ctx->curr_token.str1 = NULL;
-+	comp_ctx->curr_token.str2 = NULL;
-+#endif
-+
-+	duk_require_stack(ctx, DUK__COMPILE_ENTRY_SLOTS);
-+
-+	duk_push_dynamic_buffer(ctx, 0);       /* entry_top + 0 */
-+	duk_push_undefined(ctx);               /* entry_top + 1 */
-+	duk_push_undefined(ctx);               /* entry_top + 2 */
-+	duk_push_undefined(ctx);               /* entry_top + 3 */
-+	duk_push_undefined(ctx);               /* entry_top + 4 */
-+
-+	comp_ctx->thr = thr;
-+	comp_ctx->h_filename = h_filename;
-+	comp_ctx->tok11_idx = entry_top + 1;
-+	comp_ctx->tok12_idx = entry_top + 2;
-+	comp_ctx->tok21_idx = entry_top + 3;
-+	comp_ctx->tok22_idx = entry_top + 4;
-+	comp_ctx->recursion_limit = DUK_COMPILER_RECURSION_LIMIT;
-+
-+	/* comp_ctx->lex has been pre-initialized by caller: it has been
-+	 * zeroed and input/input_length has been set.
-+	 */
-+	comp_ctx->lex.thr = thr;
-+	/* comp_ctx->lex.input and comp_ctx->lex.input_length filled by caller */
-+	comp_ctx->lex.slot1_idx = comp_ctx->tok11_idx;
-+	comp_ctx->lex.slot2_idx = comp_ctx->tok12_idx;
-+	comp_ctx->lex.buf_idx = entry_top + 0;
-+	comp_ctx->lex.buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, entry_top + 0);
-+	DUK_ASSERT(comp_ctx->lex.buf != NULL);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(comp_ctx->lex.buf));
-+	comp_ctx->lex.token_limit = DUK_COMPILER_TOKEN_LIMIT;
-+
-+	lex_pt->offset = 0;
-+	lex_pt->line = 1;
-+	DUK_LEXER_SETPOINT(&comp_ctx->lex, lex_pt);    /* fills window */
-+	comp_ctx->curr_token.start_line = 0;  /* needed for line number tracking (becomes prev_token.start_line) */
-+
-+	/*
-+	 *  Initialize function state for a zero-argument function
-+	 */
-+
-+	duk__init_func_valstack_slots(comp_ctx);
-+	DUK_ASSERT(func->num_formals == 0);
-+
-+	if (is_funcexpr) {
-+		/* Name will be filled from function expression, not by caller.
-+		 * This case is used by Function constructor and duk_compile()
-+		 * API with the DUK_COMPILE_FUNCTION option.
-+		 */
-+		DUK_ASSERT(func->h_name == NULL);
-+	} else {
-+		duk_push_hstring_stridx(ctx, (is_eval ? DUK_STRIDX_EVAL :
-+		                                        DUK_STRIDX_GLOBAL));
-+		func->h_name = duk_get_hstring(ctx, -1);
-+	}
-+
-+	/*
-+	 *  Parse a function body or a function-like expression, depending
-+	 *  on flags.
-+	 */
-+
-+	func->is_strict = is_strict;
-+	func->is_setget = 0;
-+	func->is_decl = 0;
-+
-+	if (is_funcexpr) {
-+		func->is_function = 1;
-+		func->is_eval = 0;
-+		func->is_global = 0;
-+
-+		duk__advance(comp_ctx);  /* init 'curr_token' */
-+		duk__advance_expect(comp_ctx, DUK_TOK_FUNCTION);
-+		(void) duk__parse_func_like_raw(comp_ctx,
-+		                                0,      /* is_decl */
-+		                                0);     /* is_setget */
-+	} else {
-+		func->is_function = 0;
-+		func->is_eval = is_eval;
-+		func->is_global = !is_eval;
-+
-+		duk__parse_func_body(comp_ctx,
-+		                     1,             /* expect_eof */
-+		                     1,             /* implicit_return_value */
-+		                     -1);           /* expect_token */
-+	}
-+
-+	/*
-+	 *  Convert duk_compiler_func to a function template
-+	 */
-+
-+	duk__convert_to_func_template(comp_ctx, 0 /*force_no_namebind*/);
-+
-+	/*
-+	 *  Wrapping duk_safe_call() will mangle the stack, just return stack top
-+	 */
-+
-+	/* [ ... filename (temps) func ] */
-+
-+	return 1;
-+}
-+
-+DUK_INTERNAL void duk_js_compile(duk_hthread *thr, const duk_uint8_t *src_buffer, duk_size_t src_length, duk_small_uint_t flags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk__compiler_stkstate comp_stk;
-+	duk_compiler_ctx *prev_ctx;
-+	duk_ret_t safe_rc;
-+
-+	/* XXX: this illustrates that a C catchpoint implemented using duk_safe_call()
-+	 * is a bit heavy at the moment.  The wrapper compiles to ~180 bytes on x64.
-+	 * Alternatives would be nice.
-+	 */
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(src_buffer != NULL);
-+
-+	/* preinitialize lexer state partially */
-+	DUK_MEMZERO(&comp_stk, sizeof(comp_stk));
-+	comp_stk.flags = flags;
-+	DUK_LEXER_INITCTX(&comp_stk.comp_ctx_alloc.lex);
-+	comp_stk.comp_ctx_alloc.lex.input = src_buffer;
-+	comp_stk.comp_ctx_alloc.lex.input_length = src_length;
-+
-+	duk_push_pointer(ctx, (void *) &comp_stk);
-+
-+	/* [ ... filename &comp_stk ] */
-+
-+	prev_ctx = thr->compile_ctx;
-+	thr->compile_ctx = &comp_stk.comp_ctx_alloc;  /* for duk_error_augment.c */
-+	safe_rc = duk_safe_call(ctx, duk__js_compile_raw, 2 /*nargs*/, 1 /*nret*/);
-+	thr->compile_ctx = prev_ctx;
-+
-+	if (safe_rc != DUK_EXEC_SUCCESS) {
-+		/* Append a "(line NNN)" to the "message" property of any
-+		 * error thrown during compilation.  Usually compilation
-+		 * errors are SyntaxErrors but they can also be out-of-memory
-+		 * errors and the like.
-+		 *
-+		 * Source file/line are added to tracedata directly by
-+		 * duk_error_augment.c based on thr->compile_ctx.
-+		 */
-+
-+		/* [ ... error ] */
-+
-+		DUK_DDD(DUK_DDDPRINT("compile error, before adding line info: %!T",
-+		                     (duk_tval *) duk_get_tval(ctx, -1)));
-+		if (duk_is_object(ctx, -1)) {
-+			/* XXX: Now that fileName and lineNumber are set, this is
-+			 * unnecessary.  Remove in Duktape 1.3.0?
-+			 */
-+
-+			if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_MESSAGE)) {
-+				duk_push_sprintf(ctx, " (line %ld)", (long) comp_stk.comp_ctx_alloc.curr_token.start_line);
-+				duk_concat(ctx, 2);
-+				duk_put_prop_stridx(ctx, -2, DUK_STRIDX_MESSAGE);
-+			} else {
-+				duk_pop(ctx);
-+			}
-+		}
-+		DUK_DDD(DUK_DDDPRINT("compile error, after adding line info: %!T",
-+		                     (duk_tval *) duk_get_tval(ctx, -1)));
-+		duk_throw(ctx);
-+	}
-+
-+	/* [ ... template ] */
-+}
-+#line 1 "duk_js_executor.c"
-+/*
-+ *  Ecmascript bytecode executor.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Local forward declarations
-+ */
-+
-+DUK_LOCAL_DECL void duk__reconfig_valstack(duk_hthread *thr, duk_size_t act_idx, duk_small_uint_t retval_count);
-+
-+/*
-+ *  Arithmetic, binary, and logical helpers.
-+ *
-+ *  Note: there is no opcode for logical AND or logical OR; this is on
-+ *  purpose, because the evalution order semantics for them make such
-+ *  opcodes pretty pointless (short circuiting means they are most
-+ *  comfortably implemented as jumps).  However, a logical NOT opcode
-+ *  is useful.
-+ *
-+ *  Note: careful with duk_tval pointers here: they are potentially
-+ *  invalidated by any DECREF and almost any API call.
-+ */
-+
-+DUK_LOCAL duk_double_t duk__compute_mod(duk_double_t d1, duk_double_t d2) {
-+	/*
-+	 *  Ecmascript modulus ('%') does not match IEEE 754 "remainder"
-+	 *  operation (implemented by remainder() in C99) but does seem
-+	 *  to match ANSI C fmod().
-+	 *
-+	 *  Compare E5 Section 11.5.3 and "man fmod".
-+	 */
-+
-+	return (duk_double_t) DUK_FMOD((double) d1, (double) d2);
-+}
-+
-+DUK_LOCAL void duk__vm_arith_add(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z) {
-+	/*
-+	 *  Addition operator is different from other arithmetic
-+	 *  operations in that it also provides string concatenation.
-+	 *  Hence it is implemented separately.
-+	 *
-+	 *  There is a fast path for number addition.  Other cases go
-+	 *  through potentially multiple coercions as described in the
-+	 *  E5 specification.  It may be possible to reduce the number
-+	 *  of coercions, but this must be done carefully to preserve
-+	 *  the exact semantics.
-+	 *
-+	 *  E5 Section 11.6.1.
-+	 *
-+	 *  Custom types also have special behavior implemented here.
-+	 */
-+
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_double_union du;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
-+	DUK_ASSERT(tv_y != NULL);  /* may be reg or const */
-+	DUK_ASSERT_DISABLE(idx_z >= 0);  /* unsigned */
-+	DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
-+
-+	/*
-+	 *  Fast paths
-+	 */
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
-+		duk_int64_t v1, v2, v3;
-+		duk_int32_t v3_hi;
-+		duk_tval tv_tmp;
-+		duk_tval *tv_z;
-+
-+		/* Input values are signed 48-bit so we can detect overflow
-+		 * reliably from high bits or just a comparison.
-+		 */
-+
-+		v1 = DUK_TVAL_GET_FASTINT(tv_x);
-+		v2 = DUK_TVAL_GET_FASTINT(tv_y);
-+		v3 = v1 + v2;
-+		v3_hi = (duk_int32_t) (v3 >> 32);
-+		if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) {
-+			tv_z = thr->valstack_bottom + idx_z;
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+			DUK_TVAL_SET_FASTINT(tv_z, v3);
-+			DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z));  /* no need to incref */
-+			DUK_TVAL_DECREF(thr, &tv_tmp);   /* side effects */
-+			return;
-+		} else {
-+			/* overflow, fall through */
-+			;
-+		}
-+	}
-+#endif  /* DUK_USE_FASTINT */
-+
-+	if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
-+		duk_tval tv_tmp;
-+		duk_tval *tv_z;
-+
-+		du.d = DUK_TVAL_GET_NUMBER(tv_x) + DUK_TVAL_GET_NUMBER(tv_y);
-+		DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
-+		DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
-+
-+		tv_z = thr->valstack_bottom + idx_z;
-+		DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+		DUK_TVAL_SET_NUMBER(tv_z, du.d);
-+		DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z));  /* no need to incref */
-+		DUK_TVAL_DECREF(thr, &tv_tmp);   /* side effects */
-+		return;
-+	}
-+
-+	/*
-+	 *  Slow path: potentially requires function calls for coercion
-+	 */
-+
-+	duk_push_tval(ctx, tv_x);
-+	duk_push_tval(ctx, tv_y);
-+	duk_to_primitive(ctx, -2, DUK_HINT_NONE);  /* side effects -> don't use tv_x, tv_y after */
-+	duk_to_primitive(ctx, -1, DUK_HINT_NONE);
-+
-+	/* As a first approximation, buffer values are coerced to strings
-+	 * for addition.  This means that adding two buffers currently
-+	 * results in a string.
-+	 */
-+	if (duk_check_type_mask(ctx, -2, DUK_TYPE_MASK_STRING | DUK_TYPE_MASK_BUFFER) ||
-+	    duk_check_type_mask(ctx, -1, DUK_TYPE_MASK_STRING | DUK_TYPE_MASK_BUFFER)) {
-+		duk_to_string(ctx, -2);
-+		duk_to_string(ctx, -1);
-+		duk_concat(ctx, 2);  /* [... s1 s2] -> [... s1+s2] */
-+		duk_replace(ctx, (duk_idx_t) idx_z);  /* side effects */
-+	} else {
-+		duk_double_t d1, d2;
-+
-+		d1 = duk_to_number(ctx, -2);
-+		d2 = duk_to_number(ctx, -1);
-+		DUK_ASSERT(duk_is_number(ctx, -2));
-+		DUK_ASSERT(duk_is_number(ctx, -1));
-+		DUK_ASSERT_DOUBLE_IS_NORMALIZED(d1);
-+		DUK_ASSERT_DOUBLE_IS_NORMALIZED(d2);
-+
-+		du.d = d1 + d2;
-+		DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
-+		DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
-+
-+		duk_pop_2(ctx);
-+		duk_push_number(ctx, du.d);
-+		duk_replace(ctx, (duk_idx_t) idx_z);  /* side effects */
-+	}
-+}
-+
-+DUK_LOCAL void duk__vm_arith_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_idx_t idx_z, duk_small_uint_fast_t opcode) {
-+	/*
-+	 *  Arithmetic operations other than '+' have number-only semantics
-+	 *  and are implemented here.  The separate switch-case here means a
-+	 *  "double dispatch" of the arithmetic opcode, but saves code space.
-+	 *
-+	 *  E5 Sections 11.5, 11.5.1, 11.5.2, 11.5.3, 11.6, 11.6.1, 11.6.2, 11.6.3.
-+	 */
-+
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval tv_tmp;
-+	duk_tval *tv_z;
-+	duk_double_t d1, d2;
-+	duk_double_union du;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
-+	DUK_ASSERT(tv_y != NULL);  /* may be reg or const */
-+	DUK_ASSERT_DISABLE(idx_z >= 0);  /* unsigned */
-+	DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
-+		duk_int64_t v1, v2, v3;
-+		duk_int32_t v3_hi;
-+
-+		v1 = DUK_TVAL_GET_FASTINT(tv_x);
-+		v2 = DUK_TVAL_GET_FASTINT(tv_y);
-+
-+		switch (opcode) {
-+		case DUK_OP_SUB: {
-+			v3 = v1 - v2;
-+			break;
-+		}
-+		case DUK_OP_MUL: {
-+			/* Must ensure result is 64-bit (no overflow); a
-+			 * simple and sufficient fast path is to allow only
-+			 * 32-bit inputs.  Avoid zero inputs to avoid
-+			 * negative zero issues (-1 * 0 = -0, for instance).
-+			 */
-+			if (v1 >= -0x80000000LL && v1 <= 0x7fffffffLL && v1 != 0 &&
-+			    v2 >= -0x80000000LL && v2 <= 0x7fffffffLL && v2 != 0) {
-+				v3 = v1 * v2;
-+			} else {
-+				goto skip_fastint;
-+			}
-+			break;
-+		}
-+		case DUK_OP_DIV: {
-+			/* Don't allow a zero divisor.  Fast path check by
-+			 * "verifying" with multiplication.  Also avoid zero
-+			 * dividend to avoid negative zero issues (0 / -1 = -0
-+			 * for instance).
-+			 */
-+			if (v1 == 0 || v2 == 0) {
-+				goto skip_fastint;
-+			}
-+			v3 = v1 / v2;
-+			if (v3 * v2 != v1) {
-+				goto skip_fastint;
-+			}
-+			break;
-+		}
-+		case DUK_OP_MOD: {
-+			/* Don't allow a zero divisor.  Restrict both v1 and
-+			 * v2 to positive values to avoid compiler specific
-+			 * behavior.
-+			 */
-+			if (v1 < 1 || v2 < 1) {
-+				goto skip_fastint;
-+			}
-+			v3 = v1 % v2;
-+			DUK_ASSERT(v3 >= 0);
-+			DUK_ASSERT(v3 < v2);
-+			DUK_ASSERT(v1 - (v1 / v2) * v2 == v3);
-+			break;
-+		}
-+		default: {
-+			DUK_UNREACHABLE();
-+			goto skip_fastint;
-+		}
-+		}
-+
-+		v3_hi = (duk_int32_t) (v3 >> 32);
-+		if (DUK_LIKELY(v3_hi >= -0x8000LL && v3_hi <= 0x7fffLL)) {
-+			tv_z = thr->valstack_bottom + idx_z;
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+			DUK_TVAL_SET_FASTINT(tv_z, v3);
-+			DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z));  /* no need to incref */
-+			DUK_TVAL_DECREF(thr, &tv_tmp);   /* side effects */
-+			return;
-+		}
-+		/* fall through if overflow etc */
-+	}
-+ skip_fastint:
-+#endif  /* DUK_USE_FASTINT */
-+
-+	if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
-+		/* fast path */
-+		d1 = DUK_TVAL_GET_NUMBER(tv_x);
-+		d2 = DUK_TVAL_GET_NUMBER(tv_y);
-+	} else {
-+		duk_push_tval(ctx, tv_x);
-+		duk_push_tval(ctx, tv_y);
-+		d1 = duk_to_number(ctx, -2);  /* side effects */
-+		d2 = duk_to_number(ctx, -1);
-+		DUK_ASSERT(duk_is_number(ctx, -2));
-+		DUK_ASSERT(duk_is_number(ctx, -1));
-+		DUK_ASSERT_DOUBLE_IS_NORMALIZED(d1);
-+		DUK_ASSERT_DOUBLE_IS_NORMALIZED(d2);
-+		duk_pop_2(ctx);
-+	}
-+
-+	switch (opcode) {
-+	case DUK_OP_SUB: {
-+		du.d = d1 - d2;
-+		break;
-+	}
-+	case DUK_OP_MUL: {
-+		du.d = d1 * d2;
-+		break;
-+	}
-+	case DUK_OP_DIV: {
-+		du.d = d1 / d2;
-+		break;
-+	}
-+	case DUK_OP_MOD: {
-+		du.d = duk__compute_mod(d1, d2);
-+		break;
-+	}
-+	default: {
-+		DUK_UNREACHABLE();
-+		du.d = DUK_DOUBLE_NAN;  /* should not happen */
-+		break;
-+	}
-+	}
-+
-+	/* important to use normalized NaN with 8-byte tagged types */
-+	DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);
-+	DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
-+
-+	tv_z = thr->valstack_bottom + idx_z;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+	DUK_TVAL_SET_NUMBER(tv_z, du.d);
-+	DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z));  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);   /* side effects */
-+}
-+
-+DUK_LOCAL void duk__vm_bitwise_binary_op(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_fast_t idx_z, duk_small_uint_fast_t opcode) {
-+	/*
-+	 *  Binary bitwise operations use different coercions (ToInt32, ToUint32)
-+	 *  depending on the operation.  We coerce the arguments first using
-+	 *  ToInt32(), and then cast to an 32-bit value if necessary.  Note that
-+	 *  such casts must be correct even if there is no native 32-bit type
-+	 *  (e.g., duk_int32_t and duk_uint32_t are 64-bit).
-+	 *
-+	 *  E5 Sections 11.10, 11.7.1, 11.7.2, 11.7.3
-+	 */
-+
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval tv_tmp;
-+	duk_tval *tv_z;
-+	duk_int32_t i1, i2, i3;
-+	duk_uint32_t u1, u2, u3;
-+#if defined(DUK_USE_FASTINT)
-+	duk_int64_t fi3;
-+#else
-+	duk_double_t d3;
-+#endif
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
-+	DUK_ASSERT(tv_y != NULL);  /* may be reg or const */
-+	DUK_ASSERT_DISABLE(idx_z >= 0);  /* unsigned */
-+	DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
-+		i1 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_x);
-+		i2 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_y);
-+	}
-+	else
-+#endif  /* DUK_USE_FASTINT */
-+	{
-+		duk_push_tval(ctx, tv_x);
-+		duk_push_tval(ctx, tv_y);
-+		i1 = duk_to_int32(ctx, -2);
-+		i2 = duk_to_int32(ctx, -1);
-+		duk_pop_2(ctx);
-+	}
-+
-+	switch (opcode) {
-+	case DUK_OP_BAND: {
-+		i3 = i1 & i2;
-+		break;
-+	}
-+	case DUK_OP_BOR: {
-+		i3 = i1 | i2;
-+		break;
-+	}
-+	case DUK_OP_BXOR: {
-+		i3 = i1 ^ i2;
-+		break;
-+	}
-+	case DUK_OP_BASL: {
-+		/* Signed shift, named "arithmetic" (asl) because the result
-+		 * is signed, e.g. 4294967295 << 1 -> -2.  Note that result
-+		 * must be masked.
-+		 */
-+
-+		u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
-+		i3 = i1 << (u2 & 0x1f);                      /* E5 Section 11.7.1, steps 7 and 8 */
-+		i3 = i3 & ((duk_int32_t) 0xffffffffUL);      /* Note: left shift, should mask */
-+		break;
-+	}
-+	case DUK_OP_BASR: {
-+		/* signed shift */
-+
-+		u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
-+		i3 = i1 >> (u2 & 0x1f);                      /* E5 Section 11.7.2, steps 7 and 8 */
-+		break;
-+	}
-+	case DUK_OP_BLSR: {
-+		/* unsigned shift */
-+
-+		u1 = ((duk_uint32_t) i1) & 0xffffffffUL;
-+		u2 = ((duk_uint32_t) i2) & 0xffffffffUL;
-+
-+		/* special result value handling */
-+		u3 = u1 >> (u2 & 0x1f);     /* E5 Section 11.7.2, steps 7 and 8 */
-+#if defined(DUK_USE_FASTINT)
-+		fi3 = (duk_int64_t) u3;
-+		goto fastint_result_set;
-+#else
-+		d3 = (duk_double_t) u3;
-+		goto result_set;
-+#endif
-+	}
-+	default: {
-+		DUK_UNREACHABLE();
-+		i3 = 0;  /* should not happen */
-+		break;
-+	}
-+	}
-+
-+#if defined(DUK_USE_FASTINT)
-+	/* Result is always fastint compatible. */
-+	/* XXX: set 32-bit result (but must handle signed and unsigned) */
-+	fi3 = (duk_int64_t) i3;
-+
-+ fastint_result_set:
-+	tv_z = thr->valstack_bottom + idx_z;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+	DUK_TVAL_SET_FASTINT(tv_z, fi3);
-+	DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z));  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);   /* side effects */
-+#else
-+	d3 = (duk_double_t) i3;
-+
-+ result_set:
-+	DUK_ASSERT(!DUK_ISNAN(d3));            /* 'd3' is never NaN, so no need to normalize */
-+	DUK_ASSERT_DOUBLE_IS_NORMALIZED(d3);   /* always normalized */
-+
-+	tv_z = thr->valstack_bottom + idx_z;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+	DUK_TVAL_SET_NUMBER(tv_z, d3);
-+	DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z));  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);   /* side effects */
-+#endif
-+}
-+
-+/* In-place unary operation. */
-+DUK_LOCAL void duk__vm_arith_unary_op(duk_hthread *thr, duk_tval *tv_x, duk_idx_t idx_x, duk_small_uint_fast_t opcode) {
-+	/*
-+	 *  Arithmetic operations other than '+' have number-only semantics
-+	 *  and are implemented here.  The separate switch-case here means a
-+	 *  "double dispatch" of the arithmetic opcode, but saves code space.
-+	 *
-+	 *  E5 Sections 11.5, 11.5.1, 11.5.2, 11.5.3, 11.6, 11.6.1, 11.6.2, 11.6.3.
-+	 */
-+
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_double_t d1;
-+	duk_double_union du;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(opcode == DUK_EXTRAOP_UNM || opcode == DUK_EXTRAOP_UNP);
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv_x)) {
-+		duk_int64_t v1, v2;
-+
-+		v1 = DUK_TVAL_GET_FASTINT(tv_x);
-+		if (opcode == DUK_EXTRAOP_UNM) {
-+			/* The smallest fastint is no longer 48-bit when
-+			 * negated.  Positive zero becames negative zero
-+			 * (cannot be represented) when negated.
-+			 */
-+			if (DUK_LIKELY(v1 != DUK_FASTINT_MIN && v1 != 0)) {
-+				v2 = -v1;
-+				DUK_TVAL_SET_FASTINT(tv_x, v2);  /* no refcount changes */
-+				return;
-+			}
-+		} else {
-+			/* ToNumber() for a fastint is a no-op. */
-+			DUK_ASSERT(opcode == DUK_EXTRAOP_UNP);
-+			return;
-+		}
-+		/* fall through if overflow etc */
-+	}
-+#endif  /* DUK_USE_FASTINT */
-+
-+	if (!DUK_TVAL_IS_NUMBER(tv_x)) {
-+		duk_to_number(ctx, idx_x);  /* side effects, perform in-place */
-+		tv_x = duk_get_tval(ctx, idx_x);
-+		DUK_ASSERT(tv_x != NULL);
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x));
-+	}
-+
-+	d1 = DUK_TVAL_GET_NUMBER(tv_x);
-+	if (opcode == DUK_EXTRAOP_UNM) {
-+		du.d = -d1;
-+	} else {
-+		/* ToNumber() for a double is a no-op. */
-+		DUK_ASSERT(opcode == DUK_EXTRAOP_UNP);
-+		du.d = d1;
-+	}
-+	DUK_DBLUNION_NORMALIZE_NAN_CHECK(&du);  /* mandatory if du.d is a NaN */
-+
-+	DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
-+
-+#if defined(DUK_USE_FASTINT)
-+	/* Unary plus is used to force a fastint check, so must include
-+	 * downgrade check.
-+	 */
-+	DUK_TVAL_SET_NUMBER_CHKFAST(tv_x, du.d);  /* no refcount changes */
-+#else
-+	DUK_TVAL_SET_NUMBER(tv_x, du.d);  /* no refcount changes */
-+#endif
-+}
-+
-+DUK_LOCAL void duk__vm_bitwise_not(duk_hthread *thr, duk_tval *tv_x, duk_small_uint_fast_t idx_z) {
-+	/*
-+	 *  E5 Section 11.4.8
-+	 */
-+
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval tv_tmp;
-+	duk_tval *tv_z;
-+	duk_int32_t i1, i2;
-+#if !defined(DUK_USE_FASTINT)
-+	duk_double_t d2;
-+#endif
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
-+	DUK_ASSERT_DISABLE(idx_z >= 0);
-+	DUK_ASSERT((duk_uint_t) idx_z < (duk_uint_t) duk_get_top(ctx));
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv_x)) {
-+		i1 = (duk_int32_t) DUK_TVAL_GET_FASTINT_I32(tv_x);
-+	}
-+	else
-+#endif  /* DUK_USE_FASTINT */
-+	{
-+		duk_push_tval(ctx, tv_x);
-+		i1 = duk_to_int32(ctx, -1);
-+		duk_pop(ctx);
-+	}
-+
-+	i2 = ~i1;
-+
-+#if defined(DUK_USE_FASTINT)
-+	/* Result is always fastint compatible. */
-+	tv_z = thr->valstack_bottom + idx_z;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+	DUK_TVAL_SET_FASTINT_I32(tv_z, i2);
-+	DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z));  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);   /* side effects */
-+#else
-+	d2 = (duk_double_t) i2;
-+
-+	DUK_ASSERT(!DUK_ISNAN(d2));            /* 'val' is never NaN, so no need to normalize */
-+	DUK_ASSERT_DOUBLE_IS_NORMALIZED(d2);   /* always normalized */
-+
-+	tv_z = thr->valstack_bottom + idx_z;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+	DUK_TVAL_SET_NUMBER(tv_z, d2);
-+	DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv_z));  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);   /* side effects */
-+#endif
-+}
-+
-+DUK_LOCAL void duk__vm_logical_not(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_z) {
-+	/*
-+	 *  E5 Section 11.4.9
-+	 */
-+
-+	duk_tval tv_tmp;
-+	duk_bool_t res;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(tv_x != NULL);  /* may be reg or const */
-+	DUK_ASSERT(tv_z != NULL);  /* reg */
-+
-+	DUK_UNREF(thr);  /* w/o refcounts */
-+
-+	/* ToBoolean() does not require any operations with side effects so
-+	 * we can do it efficiently.  For footprint it would be better to use
-+	 * duk_js_toboolean() and then push+replace to the result slot.
-+	 */
-+	res = duk_js_toboolean(tv_x);  /* does not modify tv_x */
-+	DUK_ASSERT(res == 0 || res == 1);
-+	res ^= 1;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv_z);
-+	DUK_TVAL_SET_BOOLEAN(tv_z, res);  /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+}
-+
-+/*
-+ *  Longjmp handler for the bytecode executor (and a bunch of static
-+ *  helpers for it).
-+ *
-+ *  Any type of longjmp() can be caught here, including intra-function
-+ *  longjmp()s like 'break', 'continue', (slow) 'return', 'yield', etc.
-+ *
-+ *  Error policy: should not ordinarily throw errors.  Errors thrown
-+ *  will bubble outwards.
-+ *
-+ *  Returns:
-+ *    0   restart execution
-+ *    1   bytecode executor finished
-+ *    2   rethrow longjmp
-+ */
-+
-+/* XXX: duk_api operations for cross-thread reg manipulation? */
-+/* XXX: post-condition: value stack must be correct; for ecmascript functions, clamped to 'nregs' */
-+
-+#define DUK__LONGJMP_RESTART   0  /* state updated, restart bytecode execution */
-+#define DUK__LONGJMP_FINISHED  1  /* exit bytecode executor with return value */
-+#define DUK__LONGJMP_RETHROW   2  /* exit bytecode executor by rethrowing an error to caller */
-+
-+/* only called when act_idx points to an Ecmascript function */
-+DUK_LOCAL void duk__reconfig_valstack(duk_hthread *thr, duk_size_t act_idx, duk_small_uint_t retval_count) {
-+	duk_hcompiledfunction *h_func;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT_DISABLE(act_idx >= 0);  /* unsigned */
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + act_idx) != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + act_idx)));
-+	DUK_ASSERT_DISABLE(thr->callstack[act_idx].idx_retval >= 0);  /* unsigned */
-+
-+	thr->valstack_bottom = thr->valstack + thr->callstack[act_idx].idx_bottom;
-+
-+	/* clamp so that retval is at the top (retval_count == 1) or register just before
-+	 * intended retval is at the top (retval_count == 0, happens e.g. with 'finally').
-+	 */
-+	duk_set_top((duk_context *) thr,
-+	            (duk_idx_t) (thr->callstack[act_idx].idx_retval -
-+	                         thr->callstack[act_idx].idx_bottom +
-+	                         retval_count));
-+
-+	/*
-+	 *  When returning to an Ecmascript function, extend the valstack
-+	 *  top to 'nregs' always.
-+	 */
-+
-+	h_func = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(thr->callstack + act_idx);
-+
-+	(void) duk_valstack_resize_raw((duk_context *) thr,
-+	                               (thr->valstack_bottom - thr->valstack) +      /* bottom of current func */
-+	                                   h_func->nregs +                           /* reg count */
-+	                                   DUK_VALSTACK_INTERNAL_EXTRA,              /* + spare */
-+	                               DUK_VSRESIZE_FLAG_SHRINK |                    /* flags */
-+	                               0 /* no compact */ |
-+	                               DUK_VSRESIZE_FLAG_THROW);
-+
-+	duk_set_top((duk_context *) thr, h_func->nregs);
-+}
-+
-+DUK_LOCAL void duk__handle_catch_or_finally(duk_hthread *thr, duk_size_t cat_idx, duk_bool_t is_finally) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval tv_tmp;
-+	duk_tval *tv1;
-+
-+	DUK_DDD(DUK_DDDPRINT("handling catch/finally, cat_idx=%ld, is_finally=%ld",
-+	                     (long) cat_idx, (long) is_finally));
-+
-+	/*
-+	 *  Set caught value and longjmp type to catcher regs.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("writing catch registers: idx_base=%ld -> %!T, idx_base+1=%ld -> %!T",
-+	                     (long) thr->catchstack[cat_idx].idx_base,
-+	                     (duk_tval *) &thr->heap->lj.value1,
-+	                     (long) (thr->catchstack[cat_idx].idx_base + 1),
-+	                     (duk_tval *) &thr->heap->lj.value2));
-+
-+	tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+	DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1);
-+	DUK_TVAL_INCREF(thr, tv1);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+	tv1 = thr->valstack + thr->catchstack[cat_idx].idx_base + 1;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+	DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) thr->heap->lj.type);  /* XXX: set int */
-+	DUK_ASSERT(!DUK_TVAL_IS_HEAP_ALLOCATED(tv1));   /* no need to incref */
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+	/*
-+	 *  Unwind catchstack and callstack.
-+	 *
-+	 *  The 'cat_idx' catcher is always kept, even when executing finally.
-+	 */
-+
-+	duk_hthread_catchstack_unwind(thr, cat_idx + 1);
-+	duk_hthread_callstack_unwind(thr, thr->catchstack[cat_idx].callstack_index + 1);
-+
-+	/*
-+	 *  Reconfigure valstack to 'nregs' (this is always the case for
-+	 *  Ecmascript functions).
-+	 */
-+
-+	DUK_ASSERT(thr->callstack_top >= 1);
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
-+
-+	thr->valstack_bottom = thr->valstack + (thr->callstack + thr->callstack_top - 1)->idx_bottom;
-+	duk_set_top((duk_context *) thr, ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->nregs);
-+
-+	/*
-+	 *  Reset PC: resume execution from catch or finally jump slot.
-+	 */
-+
-+	(thr->callstack + thr->callstack_top - 1)->pc =
-+		thr->catchstack[cat_idx].pc_base + (is_finally ? 1 : 0);
-+
-+	/*
-+	 *  If entering a 'catch' block which requires an automatic
-+	 *  catch variable binding, create the lexical environment.
-+	 *
-+	 *  The binding is mutable (= writable) but not deletable.
-+	 *  Step 4 for the catch production in E5 Section 12.14;
-+	 *  no value is given for CreateMutableBinding 'D' argument,
-+	 *  which implies the binding is not deletable.
-+	 */
-+
-+	if (!is_finally && DUK_CAT_HAS_CATCH_BINDING_ENABLED(&thr->catchstack[cat_idx])) {
-+		duk_activation *act;
-+		duk_hobject *new_env;
-+		duk_hobject *act_lex_env;
-+
-+		DUK_DDD(DUK_DDDPRINT("catcher has an automatic catch binding"));
-+
-+		/* Note: 'act' is dangerous here because it may get invalidate at many
-+		 * points, so we re-lookup it multiple times.
-+		 */
-+		DUK_ASSERT(thr->callstack_top >= 1);
-+		act = thr->callstack + thr->callstack_top - 1;
-+
-+		if (act->lex_env == NULL) {
-+			DUK_ASSERT(act->var_env == NULL);
-+			DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
-+
-+			/* this may have side effects, so re-lookup act */
-+			duk_js_init_activation_environment_records_delayed(thr, act);
-+			act = thr->callstack + thr->callstack_top - 1;
-+		}
-+		DUK_ASSERT(act->lex_env != NULL);
-+		DUK_ASSERT(act->var_env != NULL);
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL);
-+		DUK_UNREF(act);  /* unreferenced without assertions */
-+
-+		act = thr->callstack + thr->callstack_top - 1;
-+		act_lex_env = act->lex_env;
-+		act = NULL;  /* invalidated */
-+
-+		(void) duk_push_object_helper_proto(ctx,
-+		                                    DUK_HOBJECT_FLAG_EXTENSIBLE |
-+		                                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
-+		                                    act_lex_env);
-+		new_env = duk_require_hobject(ctx, -1);
-+		DUK_ASSERT(new_env != NULL);
-+		DUK_DDD(DUK_DDDPRINT("new_env allocated: %!iO", (duk_heaphdr *) new_env));
-+
-+		/* Note: currently the catch binding is handled without a register
-+		 * binding because we don't support dynamic register bindings (they
-+		 * must be fixed for an entire function).  So, there is no need to
-+		 * record regbases etc.
-+		 */
-+
-+		DUK_ASSERT(thr->catchstack[cat_idx].h_varname != NULL);
-+		duk_push_hstring(ctx, thr->catchstack[cat_idx].h_varname);
-+		duk_push_tval(ctx, &thr->heap->lj.value1);
-+		duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_W);  /* writable, not configurable */
-+
-+		act = thr->callstack + thr->callstack_top - 1;
-+		act->lex_env = new_env;
-+		DUK_HOBJECT_INCREF(thr, new_env);  /* reachable through activation */
-+
-+		DUK_CAT_SET_LEXENV_ACTIVE(&thr->catchstack[cat_idx]);
-+
-+		duk_pop(ctx);
-+
-+		DUK_DDD(DUK_DDDPRINT("new_env finished: %!iO", (duk_heaphdr *) new_env));
-+	}
-+
-+	if (is_finally) {
-+		DUK_CAT_CLEAR_FINALLY_ENABLED(&thr->catchstack[cat_idx]);
-+	} else {
-+		DUK_CAT_CLEAR_CATCH_ENABLED(&thr->catchstack[cat_idx]);
-+	}
-+}
-+
-+DUK_LOCAL void duk__handle_label(duk_hthread *thr, duk_size_t cat_idx) {
-+	duk_activation *act;
-+
-+	/* no callstack changes, no value stack changes */
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->callstack_top >= 1);
-+
-+	act = thr->callstack + thr->callstack_top - 1;
-+
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(act) != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(act)));
-+
-+	/* +0 = break, +1 = continue */
-+	act->pc = thr->catchstack[cat_idx].pc_base + (thr->heap->lj.type == DUK_LJ_TYPE_CONTINUE ? 1 : 0);
-+	act = NULL;  /* invalidated */
-+
-+	duk_hthread_catchstack_unwind(thr, cat_idx + 1);  /* keep label catcher */
-+	/* no need to unwind callstack */
-+
-+	/* valstack should not need changes */
-+#if defined(DUK_USE_ASSERTIONS)
-+	act = thr->callstack + thr->callstack_top - 1;
-+	DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack_bottom) ==
-+	           (duk_size_t) ((duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act))->nregs);
-+#endif
-+}
-+
-+/* Note: called for DUK_LJ_TYPE_YIELD and for DUK_LJ_TYPE_RETURN, when a
-+ * return terminates a thread and yields to the resumer.
-+ */
-+DUK_LOCAL void duk__handle_yield(duk_hthread *thr, duk_hthread *resumer, duk_size_t act_idx) {
-+	duk_tval tv_tmp;
-+	duk_tval *tv1;
-+
-+	/* this may also be called for DUK_LJ_TYPE_RETURN; this is OK as long as
-+	 * lj.value1 is correct.
-+	 */
-+
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + act_idx) != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + act_idx)));  /* resume caller must be an ecmascript func */
-+
-+	DUK_DDD(DUK_DDDPRINT("resume idx_retval is %ld", (long) resumer->callstack[act_idx].idx_retval));
-+
-+	tv1 = resumer->valstack + resumer->callstack[act_idx].idx_retval;  /* return value from Duktape.Thread.resume() */
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+	DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1);
-+	DUK_TVAL_INCREF(thr, tv1);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+	duk_hthread_callstack_unwind(resumer, act_idx + 1);  /* unwind to 'resume' caller */
-+
-+	/* no need to unwind catchstack */
-+	duk__reconfig_valstack(resumer, act_idx, 1);  /* 1 = have retval */
-+
-+	/* caller must change active thread, and set thr->resumer to NULL */
-+}
-+
-+DUK_LOCAL
-+duk_small_uint_t duk__handle_longjmp(duk_hthread *thr,
-+                                     duk_hthread *entry_thread,
-+                                     duk_size_t entry_callstack_top) {
-+	duk_tval tv_tmp;
-+	duk_size_t entry_callstack_index;
-+	duk_small_uint_t retval = DUK__LONGJMP_RESTART;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(entry_thread != NULL);
-+	DUK_ASSERT(entry_callstack_top > 0);  /* guarantees entry_callstack_top - 1 >= 0 */
-+
-+	entry_callstack_index = entry_callstack_top - 1;
-+
-+	/* 'thr' is the current thread, as no-one resumes except us and we
-+	 * switch 'thr' in that case.
-+	 */
-+
-+	/*
-+	 *  (Re)try handling the longjmp.
-+	 *
-+	 *  A longjmp handler may convert the longjmp to a different type and
-+	 *  "virtually" rethrow by goto'ing to 'check_longjmp'.  Before the goto,
-+	 *  the following must be updated:
-+	 *    - the heap 'lj' state
-+	 *    - 'thr' must reflect the "throwing" thread
-+	 */
-+
-+ check_longjmp:
-+
-+	DUK_DD(DUK_DDPRINT("handling longjmp: type=%ld, value1=%!T, value2=%!T, iserror=%ld",
-+	                   (long) thr->heap->lj.type,
-+	                   (duk_tval *) &thr->heap->lj.value1,
-+	                   (duk_tval *) &thr->heap->lj.value2,
-+	                   (long) thr->heap->lj.iserror));
-+
-+	switch (thr->heap->lj.type) {
-+
-+	case DUK_LJ_TYPE_RESUME: {
-+		/*
-+		 *  Note: lj.value1 is 'value', lj.value2 is 'resumee'.
-+		 *  This differs from YIELD.
-+		 */
-+
-+		duk_tval *tv;
-+		duk_tval *tv2;
-+		duk_size_t act_idx;
-+		duk_hthread *resumee;
-+
-+		/* duk_bi_duk_object_yield() and duk_bi_duk_object_resume() ensure all of these are met */
-+
-+		DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);                                                         /* unchanged by Duktape.Thread.resume() */
-+		DUK_ASSERT(thr->callstack_top >= 2);                                                                         /* Ecmascript activation + Duktape.Thread.resume() activation */
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL &&
-+		           DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)) &&
-+		           ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->func == duk_bi_thread_resume);
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL &&
-+		           DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2)));      /* an Ecmascript function */
-+		DUK_ASSERT_DISABLE((thr->callstack + thr->callstack_top - 2)->idx_retval >= 0);                              /* unsigned */
-+
-+		tv = &thr->heap->lj.value2;  /* resumee */
-+		DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+		DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL);
-+		DUK_ASSERT(DUK_HOBJECT_IS_THREAD(DUK_TVAL_GET_OBJECT(tv)));
-+		resumee = (duk_hthread *) DUK_TVAL_GET_OBJECT(tv);
-+
-+		DUK_ASSERT(resumee != NULL);
-+		DUK_ASSERT(resumee->resumer == NULL);
-+		DUK_ASSERT(resumee->state == DUK_HTHREAD_STATE_INACTIVE ||
-+		           resumee->state == DUK_HTHREAD_STATE_YIELDED);                                                     /* checked by Duktape.Thread.resume() */
-+		DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED ||
-+		           resumee->callstack_top >= 2);                                                                     /* YIELDED: Ecmascript activation + Duktape.Thread.yield() activation */
-+		DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED ||
-+		           (DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1) != NULL &&
-+		            DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1)) &&
-+		            ((duk_hnativefunction *) DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 1))->func == duk_bi_thread_yield));
-+		DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_YIELDED ||
-+		           (DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 2) != NULL &&
-+		            DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumee->callstack + resumee->callstack_top - 2))));      /* an Ecmascript function */
-+		DUK_ASSERT_DISABLE(resumee->state != DUK_HTHREAD_STATE_YIELDED ||
-+		           (resumee->callstack + resumee->callstack_top - 2)->idx_retval >= 0);                              /* idx_retval unsigned */
-+		DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_INACTIVE ||
-+		           resumee->callstack_top == 0);                                                                     /* INACTIVE: no activation, single function value on valstack */
-+		DUK_ASSERT(resumee->state != DUK_HTHREAD_STATE_INACTIVE ||
-+		           (resumee->valstack_top == resumee->valstack + 1 &&
-+		            DUK_TVAL_IS_OBJECT(resumee->valstack_top - 1) &&
-+		            DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_TVAL_GET_OBJECT(resumee->valstack_top - 1))));
-+
-+		if (thr->heap->lj.iserror) {
-+			/*
-+			 *  Throw the error in the resumed thread's context; the
-+			 *  error value is pushed onto the resumee valstack.
-+			 *
-+			 *  Note: the callstack of the target may empty in this case
-+			 *  too (i.e. the target thread has never been resumed).  The
-+			 *  value stack will contain the initial function in that case,
-+			 *  which we simply ignore.
-+			 */
-+
-+			resumee->resumer = thr;
-+			resumee->state = DUK_HTHREAD_STATE_RUNNING;
-+			thr->state = DUK_HTHREAD_STATE_RESUMED;
-+			DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
-+			thr = resumee;
-+
-+			thr->heap->lj.type = DUK_LJ_TYPE_THROW;
-+
-+			/* thr->heap->lj.value1 is already the value to throw */
-+			/* thr->heap->lj.value2 is 'thread', will be wiped out at the end */
-+
-+			DUK_ASSERT(thr->heap->lj.iserror);  /* already set */
-+
-+			DUK_DD(DUK_DDPRINT("-> resume with an error, converted to a throw in the resumee, propagate"));
-+			goto check_longjmp;
-+		} else if (resumee->state == DUK_HTHREAD_STATE_YIELDED) {
-+			act_idx = resumee->callstack_top - 2;  /* Ecmascript function */
-+			DUK_ASSERT_DISABLE(resumee->callstack[act_idx].idx_retval >= 0);  /* unsigned */
-+
-+			tv = resumee->valstack + resumee->callstack[act_idx].idx_retval;  /* return value from Duktape.Thread.yield() */
-+			DUK_ASSERT(tv >= resumee->valstack && tv < resumee->valstack_top);
-+			tv2 = &thr->heap->lj.value1;
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+			DUK_TVAL_SET_TVAL(tv, tv2);
-+			DUK_TVAL_INCREF(thr, tv);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+			duk_hthread_callstack_unwind(resumee, act_idx + 1);  /* unwind to 'yield' caller */
-+
-+			/* no need to unwind catchstack */
-+
-+			duk__reconfig_valstack(resumee, act_idx, 1);  /* 1 = have retval */
-+
-+			resumee->resumer = thr;
-+			resumee->state = DUK_HTHREAD_STATE_RUNNING;
-+			thr->state = DUK_HTHREAD_STATE_RESUMED;
-+			DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
-+#if 0
-+			thr = resumee;  /* not needed, as we exit right away */
-+#endif
-+			DUK_DD(DUK_DDPRINT("-> resume with a value, restart execution in resumee"));
-+			retval = DUK__LONGJMP_RESTART;
-+			goto wipe_and_return;
-+		} else {
-+			duk_small_uint_t call_flags;
-+			duk_bool_t setup_rc;
-+
-+			/* resumee: [... initial_func]  (currently actually: [initial_func]) */
-+
-+			duk_push_undefined((duk_context *) resumee);
-+			tv = &thr->heap->lj.value1;
-+			duk_push_tval((duk_context *) resumee, tv);
-+
-+			/* resumee: [... initial_func undefined(= this) resume_value ] */
-+
-+			call_flags = DUK_CALL_FLAG_IS_RESUME;  /* is resume, not a tailcall */
-+
-+			setup_rc = duk_handle_ecma_call_setup(resumee,
-+			                                      1,              /* num_stack_args */
-+			                                      call_flags);    /* call_flags */
-+			if (setup_rc == 0) {
-+				/* Shouldn't happen but check anyway. */
-+				DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR);
-+			}
-+
-+			resumee->resumer = thr;
-+			resumee->state = DUK_HTHREAD_STATE_RUNNING;
-+			thr->state = DUK_HTHREAD_STATE_RESUMED;
-+			DUK_HEAP_SWITCH_THREAD(thr->heap, resumee);
-+#if 0
-+			thr = resumee;  /* not needed, as we exit right away */
-+#endif
-+			DUK_DD(DUK_DDPRINT("-> resume with a value, restart execution in resumee"));
-+			retval = DUK__LONGJMP_RESTART;
-+			goto wipe_and_return;
-+		}
-+		DUK_UNREACHABLE();
-+		break;  /* never here */
-+	}
-+
-+	case DUK_LJ_TYPE_YIELD: {
-+		/*
-+		 *  Currently only allowed only if yielding thread has only
-+		 *  Ecmascript activations (except for the Duktape.Thread.yield()
-+		 *  call at the callstack top) and none of them constructor
-+		 *  calls.
-+		 *
-+		 *  This excludes the 'entry' thread which will always have
-+		 *  a preventcount > 0.
-+		 */
-+
-+		duk_hthread *resumer;
-+
-+		/* duk_bi_duk_object_yield() and duk_bi_duk_object_resume() ensure all of these are met */
-+
-+		DUK_ASSERT(thr != entry_thread);                                                                             /* Duktape.Thread.yield() should prevent */
-+		DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);                                                         /* unchanged from Duktape.Thread.yield() */
-+		DUK_ASSERT(thr->callstack_top >= 2);                                                                         /* Ecmascript activation + Duktape.Thread.yield() activation */
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL &&
-+		           DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)) &&
-+		           ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1))->func == duk_bi_thread_yield);
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL &&
-+		           DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2)));      /* an Ecmascript function */
-+		DUK_ASSERT_DISABLE((thr->callstack + thr->callstack_top - 2)->idx_retval >= 0);                              /* unsigned */
-+
-+		resumer = thr->resumer;
-+
-+		DUK_ASSERT(resumer != NULL);
-+		DUK_ASSERT(resumer->state == DUK_HTHREAD_STATE_RESUMED);                                                     /* written by a previous RESUME handling */
-+		DUK_ASSERT(resumer->callstack_top >= 2);                                                                     /* Ecmascript activation + Duktape.Thread.resume() activation */
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1) != NULL &&
-+		           DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1)) &&
-+		           ((duk_hnativefunction *) DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 1))->func == duk_bi_thread_resume);
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 2) != NULL &&
-+		           DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(resumer->callstack + resumer->callstack_top - 2)));        /* an Ecmascript function */
-+		DUK_ASSERT_DISABLE((resumer->callstack + resumer->callstack_top - 2)->idx_retval >= 0);                      /* unsigned */
-+
-+		if (thr->heap->lj.iserror) {
-+			thr->state = DUK_HTHREAD_STATE_YIELDED;
-+			thr->resumer = NULL;
-+			resumer->state = DUK_HTHREAD_STATE_RUNNING;
-+			DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
-+			thr = resumer;
-+
-+			thr->heap->lj.type = DUK_LJ_TYPE_THROW;
-+			/* lj.value1 is already set */
-+			DUK_ASSERT(thr->heap->lj.iserror);  /* already set */
-+
-+			DUK_DD(DUK_DDPRINT("-> yield an error, converted to a throw in the resumer, propagate"));
-+			goto check_longjmp;
-+		} else {
-+			duk__handle_yield(thr, resumer, resumer->callstack_top - 2);
-+
-+			thr->state = DUK_HTHREAD_STATE_YIELDED;
-+			thr->resumer = NULL;
-+			resumer->state = DUK_HTHREAD_STATE_RUNNING;
-+			DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
-+#if 0
-+			thr = resumer;  /* not needed, as we exit right away */
-+#endif
-+
-+			DUK_DD(DUK_DDPRINT("-> yield a value, restart execution in resumer"));
-+			retval = DUK__LONGJMP_RESTART;
-+			goto wipe_and_return;
-+		}
-+		DUK_UNREACHABLE();
-+		break;  /* never here */
-+	}
-+
-+	case DUK_LJ_TYPE_RETURN: {
-+		/*
-+		 *  Four possible outcomes:
-+		 *    * A 'finally' in the same function catches the 'return'.
-+		 *      (or)
-+		 *    * The return happens at the entry level of the bytecode
-+		 *      executor, so return from the executor (in C stack).
-+		 *      (or)
-+		 *    * There is a calling (Ecmascript) activation in the call
-+		 *      stack => return to it.
-+		 *      (or)
-+		 *    * There is no calling activation, and the thread is
-+		 *      terminated.  There is always a resumer in this case,
-+		 *      which gets the return value similarly to a 'yield'
-+		 *      (except that the current thread can no longer be
-+		 *      resumed).
-+		 */
-+
-+		duk_tval *tv1;
-+		duk_hthread *resumer;
-+		duk_catcher *cat;
-+		duk_size_t orig_callstack_index;
-+
-+		DUK_ASSERT(thr != NULL);
-+		DUK_ASSERT(thr->callstack_top >= 1);
-+		DUK_ASSERT(thr->catchstack != NULL);
-+
-+		/* XXX: does not work if thr->catchstack is NULL */
-+		/* XXX: does not work if thr->catchstack is allocated but lowest pointer */
-+
-+		cat = thr->catchstack + thr->catchstack_top - 1;  /* may be < thr->catchstack initially */
-+		DUK_ASSERT(thr->callstack_top > 0);  /* ensures callstack_top - 1 >= 0 */
-+		orig_callstack_index = thr->callstack_top - 1;
-+
-+		while (cat >= thr->catchstack) {
-+			if (cat->callstack_index != orig_callstack_index) {
-+				break;
-+			}
-+			if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF &&
-+			    DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
-+				/* 'finally' catches */
-+				duk__handle_catch_or_finally(thr,
-+				                             cat - thr->catchstack,
-+				                             1); /* is_finally */
-+
-+				DUK_DD(DUK_DDPRINT("-> return caught by a finally (in the same function), restart execution"));
-+				retval = DUK__LONGJMP_RESTART;
-+				goto wipe_and_return;
-+			}
-+			cat--;
-+		}
-+		/* if out of catchstack, cat = thr->catchstack - 1 */
-+
-+		DUK_DD(DUK_DDPRINT("no catcher in catch stack, return to calling activation / yield"));
-+
-+		/* return to calling activation (if any) */
-+
-+		if (thr == entry_thread &&
-+		    thr->callstack_top == entry_callstack_top) {
-+			/* return to the bytecode executor caller */
-+
-+			duk_push_tval((duk_context *) thr, &thr->heap->lj.value1);
-+
-+			/* [ ... retval ] */
-+
-+			DUK_DD(DUK_DDPRINT("-> return propagated up to entry level, exit bytecode executor"));
-+			retval = DUK__LONGJMP_FINISHED;
-+			goto wipe_and_return;
-+		}
-+
-+		if (thr->callstack_top >= 2) {
-+			/* there is a caller; it MUST be an Ecmascript caller (otherwise it would
-+			 * match entry level check)
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("slow return to Ecmascript caller, idx_retval=%ld, lj_value1=%!T",
-+			                     (long) (thr->callstack + thr->callstack_top - 2)->idx_retval,
-+			                     (duk_tval *) &thr->heap->lj.value1));
-+
-+			DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2)));   /* must be ecmascript */
-+
-+			tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval;
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+			DUK_TVAL_SET_TVAL(tv1, &thr->heap->lj.value1);
-+			DUK_TVAL_INCREF(thr, tv1);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+			DUK_DDD(DUK_DDDPRINT("return value at idx_retval=%ld is %!T",
-+			                     (long) (thr->callstack + thr->callstack_top - 2)->idx_retval,
-+			                     (duk_tval *) (thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval)));
-+
-+			duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1);  /* leave 'cat' as top catcher (also works if catchstack exhausted) */
-+			duk_hthread_callstack_unwind(thr, thr->callstack_top - 1);
-+			duk__reconfig_valstack(thr, thr->callstack_top - 1, 1);    /* new top, i.e. callee */
-+
-+			DUK_DD(DUK_DDPRINT("-> return not caught, restart execution in caller"));
-+			retval = DUK__LONGJMP_RESTART;
-+			goto wipe_and_return;
-+		}
-+
-+		DUK_DD(DUK_DDPRINT("no calling activation, thread finishes (similar to yield)"));
-+
-+		DUK_ASSERT(thr->resumer != NULL);
-+		DUK_ASSERT(thr->resumer->callstack_top >= 2);  /* Ecmascript activation + Duktape.Thread.resume() activation */
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1) != NULL &&
-+		           DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1)) &&
-+		           ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume);  /* Duktape.Thread.resume() */
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2) != NULL &&
-+		           DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2)));  /* an Ecmascript function */
-+		DUK_ASSERT_DISABLE((thr->resumer->callstack + thr->resumer->callstack_top - 2)->idx_retval >= 0);                /* unsigned */
-+		DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
-+		DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED);
-+
-+		resumer = thr->resumer;
-+
-+		duk__handle_yield(thr, resumer, resumer->callstack_top - 2);
-+
-+		duk_hthread_terminate(thr);  /* updates thread state, minimizes its allocations */
-+		DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_TERMINATED);
-+
-+		thr->resumer = NULL;
-+		resumer->state = DUK_HTHREAD_STATE_RUNNING;
-+		DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
-+#if 0
-+		thr = resumer;  /* not needed */
-+#endif
-+
-+		DUK_DD(DUK_DDPRINT("-> return not caught, thread terminated; handle like yield, restart execution in resumer"));
-+		retval = DUK__LONGJMP_RESTART;
-+		goto wipe_and_return;
-+	}
-+
-+	case DUK_LJ_TYPE_BREAK:
-+	case DUK_LJ_TYPE_CONTINUE: {
-+		/*
-+		 *  Find a matching label catcher or 'finally' catcher in
-+		 *  the same function.
-+		 *
-+		 *  A label catcher must always exist and will match unless
-+		 *  a 'finally' captures the break/continue first.  It is the
-+		 *  compiler's responsibility to ensure that labels are used
-+		 *  correctly.
-+		 */
-+
-+		duk_catcher *cat;
-+		duk_size_t orig_callstack_index;
-+		duk_uint_t lj_label;
-+
-+		cat = thr->catchstack + thr->catchstack_top - 1;
-+		orig_callstack_index = cat->callstack_index;
-+
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(&thr->heap->lj.value1));
-+		lj_label = (duk_uint_t) DUK_TVAL_GET_NUMBER(&thr->heap->lj.value1);
-+
-+		DUK_DDD(DUK_DDDPRINT("handling break/continue with label=%ld, callstack index=%ld",
-+		                     (long) lj_label, (long) cat->callstack_index));
-+
-+		while (cat >= thr->catchstack) {
-+			if (cat->callstack_index != orig_callstack_index) {
-+				break;
-+			}
-+			DUK_DDD(DUK_DDDPRINT("considering catcher %ld: type=%ld label=%ld",
-+			                     (long) (cat - thr->catchstack),
-+			                     (long) DUK_CAT_GET_TYPE(cat),
-+			                     (long) DUK_CAT_GET_LABEL(cat)));
-+
-+			if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF &&
-+			    DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
-+				/* finally catches */
-+				duk__handle_catch_or_finally(thr,
-+				                             cat - thr->catchstack,
-+				                             1); /* is_finally */
-+
-+				DUK_DD(DUK_DDPRINT("-> break/continue caught by a finally (in the same function), restart execution"));
-+				retval = DUK__LONGJMP_RESTART;
-+				goto wipe_and_return;
-+			}
-+			if (DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_LABEL &&
-+			    (duk_uint_t) DUK_CAT_GET_LABEL(cat) == lj_label) {
-+				/* found label */
-+				duk__handle_label(thr,
-+				                  cat - thr->catchstack);
-+
-+				DUK_DD(DUK_DDPRINT("-> break/continue caught by a label catcher (in the same function), restart execution"));
-+				retval = DUK__LONGJMP_RESTART;
-+				goto wipe_and_return;
-+			}
-+			cat--;
-+		}
-+
-+		/* should never happen, but be robust */
-+		DUK_D(DUK_DPRINT("break/continue not caught by anything in the current function (should never happen)"));
-+		goto convert_to_internal_error;
-+	}
-+
-+	case DUK_LJ_TYPE_THROW: {
-+		/*
-+		 *  Three possible outcomes:
-+		 *    * A try or finally catcher is found => resume there.
-+		 *      (or)
-+		 *    * The error propagates to the bytecode executor entry
-+		 *      level (and we're in the entry thread) => rethrow
-+		 *      with a new longjmp(), after restoring the previous
-+		 *      catchpoint.
-+		 *    * The error is not caught in the current thread, so
-+		 *      the thread finishes with an error.  This works like
-+		 *      a yielded error, except that the thread is finished
-+		 *      and can no longer be resumed.  (There is always a
-+		 *      resumer in this case.)
-+		 *
-+		 *  Note: until we hit the entry level, there can only be
-+		 *  Ecmascript activations.
-+		 */
-+
-+		duk_catcher *cat;
-+		duk_hthread *resumer;
-+
-+		cat = thr->catchstack + thr->catchstack_top - 1;
-+		while (cat >= thr->catchstack) {
-+			if (thr == entry_thread &&
-+			    cat->callstack_index < entry_callstack_index) {
-+				/* entry level reached */
-+				break;
-+			}
-+
-+			if (DUK_CAT_HAS_CATCH_ENABLED(cat)) {
-+				/* try catches */
-+				DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF);
-+
-+				duk__handle_catch_or_finally(thr,
-+				                             cat - thr->catchstack,
-+				                             0); /* is_finally */
-+
-+				DUK_DD(DUK_DDPRINT("-> throw caught by a 'catch' clause, restart execution"));
-+				retval = DUK__LONGJMP_RESTART;
-+				goto wipe_and_return;
-+			}
-+
-+			if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
-+				DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_TCF);
-+				DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat));
-+
-+				duk__handle_catch_or_finally(thr,
-+				                             cat - thr->catchstack,
-+				                             1); /* is_finally */
-+
-+				DUK_DD(DUK_DDPRINT("-> throw caught by a 'finally' clause, restart execution"));
-+				retval = DUK__LONGJMP_RESTART;
-+				goto wipe_and_return;
-+			}
-+
-+			cat--;
-+		}
-+
-+		if (thr == entry_thread) {
-+			/* not caught by anything before entry level; rethrow and let the
-+			 * final catcher unwind everything
-+			 */
-+#if 0
-+			duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1);  /* leave 'cat' as top catcher (also works if catchstack exhausted) */
-+			duk_hthread_callstack_unwind(thr, entry_callstack_index + 1);
-+
-+#endif
-+			DUK_D(DUK_DPRINT("-> throw propagated up to entry level, rethrow and exit bytecode executor"));
-+			retval = DUK__LONGJMP_RETHROW;
-+			goto just_return;
-+			/* Note: MUST NOT wipe_and_return here, as heap->lj must remain intact */
-+		}
-+
-+		DUK_DD(DUK_DDPRINT("not caught by current thread, yield error to resumer"));
-+
-+		/* not caught by current thread, thread terminates (yield error to resumer);
-+		 * note that this may cause a cascade if the resumer terminates with an uncaught
-+		 * exception etc (this is OK, but needs careful testing)
-+		 */
-+
-+		DUK_ASSERT(thr->resumer != NULL);
-+		DUK_ASSERT(thr->resumer->callstack_top >= 2);  /* Ecmascript activation + Duktape.Thread.resume() activation */
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1) != NULL &&
-+		           DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1)) &&
-+		           ((duk_hnativefunction *) DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 1))->func == duk_bi_thread_resume);  /* Duktape.Thread.resume() */
-+		DUK_ASSERT(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2) != NULL &&
-+		           DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->resumer->callstack + thr->resumer->callstack_top - 2)));  /* an Ecmascript function */
-+
-+		resumer = thr->resumer;
-+
-+		/* reset longjmp */
-+
-+		DUK_ASSERT(thr->heap->lj.type == DUK_LJ_TYPE_THROW);  /* already set */
-+		/* lj.value1 already set */
-+
-+		duk_hthread_terminate(thr);  /* updates thread state, minimizes its allocations */
-+		DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_TERMINATED);
-+
-+		thr->resumer = NULL;
-+		resumer->state = DUK_HTHREAD_STATE_RUNNING;
-+		DUK_HEAP_SWITCH_THREAD(thr->heap, resumer);
-+		thr = resumer;
-+		goto check_longjmp;
-+	}
-+
-+	case DUK_LJ_TYPE_NORMAL: {
-+		DUK_D(DUK_DPRINT("caught DUK_LJ_TYPE_NORMAL, should never happen, treat as internal error"));
-+		goto convert_to_internal_error;
-+	}
-+
-+	default: {
-+		/* should never happen, but be robust */
-+		DUK_D(DUK_DPRINT("caught unknown longjmp type %ld, treat as internal error", (long) thr->heap->lj.type));
-+		goto convert_to_internal_error;
-+	}
-+
-+	}  /* end switch */
-+
-+	DUK_UNREACHABLE();
-+
-+ wipe_and_return:
-+	/* this is not strictly necessary, but helps debugging */
-+	thr->heap->lj.type = DUK_LJ_TYPE_UNKNOWN;
-+	thr->heap->lj.iserror = 0;
-+
-+	DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value1);
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value1);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+	DUK_TVAL_SET_TVAL(&tv_tmp, &thr->heap->lj.value2);
-+	DUK_TVAL_SET_UNDEFINED_UNUSED(&thr->heap->lj.value2);
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+ just_return:
-+	return retval;
-+
-+ convert_to_internal_error:
-+	/* This could also be thrown internally (set the error, goto check_longjmp),
-+	 * but it's better for internal errors to bubble outwards.
-+	 */
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR_EXEC_LONGJMP);
-+	DUK_UNREACHABLE();
-+	return retval;
-+}
-+
-+/* XXX: Disabled for 1.0 release.  This needs to handle unwinding for label
-+ * sites (which are created for explicit labels but also for control statements
-+ * like for-loops).  At that point it's quite close to the "slow return" handler
-+ * except for longjmp().  Perhaps all returns could initially be handled as fast
-+ * returns and only converted to longjmp()s when basic handling won't do?
-+ */
-+#if 0
-+/* Try a fast return.  Return false if fails, so that a slow return can be done
-+ * instead.
-+ */
-+DUK_LOCAL
-+duk_bool_t duk__handle_fast_return(duk_hthread *thr,
-+                                   duk_tval *tv_retval,
-+                                   duk_hthread *entry_thread,
-+                                   duk_size_t entry_callstack_top) {
-+	duk_tval tv_tmp;
-+	duk_tval *tv1;
-+
-+	/* retval == NULL indicates 'undefined' return value */
-+
-+	if (thr == entry_thread && thr->callstack_top == entry_callstack_top) {
-+		DUK_DDD(DUK_DDDPRINT("reject fast return: return would exit bytecode executor to caller"));
-+		return 0;
-+	}
-+	if (thr->callstack_top <= 1) {
-+		DUK_DDD(DUK_DDDPRINT("reject fast return: there is no caller in this callstack (thread yield)"));
-+		return 0;
-+	}
-+
-+	/* There is a caller, and it must be an Ecmascript caller (otherwise
-+	 * it would have matched the entry level check).
-+	 */
-+	DUK_ASSERT(thr->callstack_top >= 2);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2)));   /* must be ecmascript */
-+
-+	tv1 = thr->valstack + (thr->callstack + thr->callstack_top - 2)->idx_retval;
-+	DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+	if (tv_retval) {
-+		DUK_TVAL_SET_TVAL(tv1, tv_retval);
-+		DUK_TVAL_INCREF(thr, tv1);
-+	} else {
-+		DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1);
-+		/* no need to incref */
-+	}
-+	DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+
-+	/* No catchstack to unwind. */
-+#if 0
-+	duk_hthread_catchstack_unwind(thr, (cat - thr->catchstack) + 1);  /* leave 'cat' as top catcher (also works if catchstack exhausted) */
-+#endif
-+	duk_hthread_callstack_unwind(thr, thr->callstack_top - 1);
-+	duk__reconfig_valstack(thr, thr->callstack_top - 1, 1);    /* new top, i.e. callee */
-+
-+	DUK_DDD(DUK_DDDPRINT("fast return accepted"));
-+	return 1;
-+}
-+#endif
-+
-+/*
-+ *  Executor interrupt handling
-+ *
-+ *  The handler is called whenever the interrupt countdown reaches zero
-+ *  (or below).  The handler must perform whatever checks are activated,
-+ *  e.g. check for cumulative step count to impose an execution step
-+ *  limit or check for breakpoints or other debugger interaction.
-+ *
-+ *  When the actions are done, the handler must reinit the interrupt
-+ *  init and counter values.  The 'init' value must indicate how many
-+ *  bytecode instructions are executed before the next interrupt.  The
-+ *  counter must interface with the bytecode executor loop.  Concretely,
-+ *  the new init value is normally one higher than the new counter value.
-+ *  For instance, to execute exactly one bytecode instruction the init
-+ *  value is set to 1 and the counter to 0.  If an error is thrown by the
-+ *  interrupt handler, the counters are set to the same value (e.g. both
-+ *  to 0 to cause an interrupt when the next bytecode instruction is about
-+ *  to be executed after error handling).
-+ *
-+ *  Maintaining the init/counter value properly is important for accurate
-+ *  behavior.  For instance, executor step limit needs a cumulative step
-+ *  count which is simply computed as a sum of 'init' values.  This must
-+ *  work accurately even when single stepping.
-+ */
-+
-+#ifdef DUK_USE_INTERRUPT_COUNTER
-+
-+#define DUK__INT_NOACTION    0    /* no specific action, resume normal execution */
-+#define DUK__INT_RESTART     1    /* must "goto restart_execution", e.g. breakpoints changed */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+DUK_LOCAL void duk__interrupt_handle_debugger(duk_hthread *thr, duk_bool_t *out_immediate, duk_small_uint_t *out_interrupt_retval) {
-+	duk_context *ctx;
-+	duk_activation *act;
-+	duk_breakpoint *bp;
-+	duk_breakpoint **bp_active;
-+	duk_uint_fast32_t line = 0;
-+	duk_bool_t send_status;
-+	duk_bool_t process_messages;
-+	duk_bool_t processed_messages = 0;
-+
-+	ctx = (duk_context *) thr;
-+	act = thr->callstack + thr->callstack_top - 1;
-+
-+	/* It might seem that replacing 'thr->heap' with just 'heap' below
-+	 * might be a good idea, but it increases code size slightly
-+	 * (probably due to unnecessary spilling) at least on x64.
-+	 */
-+
-+	/*
-+	 *  Breakpoint and step state checks
-+	 */
-+
-+	if (act->flags & DUK_ACT_FLAG_BREAKPOINT_ACTIVE ||
-+	    (thr->heap->dbg_step_thread == thr &&
-+	     thr->heap->dbg_step_csindex == thr->callstack_top - 1)) {
-+		line = duk_debug_curr_line(thr);
-+
-+		if (act->prev_line != line) {
-+			DUK_DDD(DUK_DDDPRINT("PC=%ld line=%ld; line transition: %ld -> %ld",
-+			                     (long) act->pc, (long) line, (long) act->prev_line, (long) line));
-+
-+			/* Stepped?  Step out is handled by callstack unwind. */
-+			if ((thr->heap->dbg_step_type == DUK_STEP_TYPE_INTO ||
-+			     thr->heap->dbg_step_type == DUK_STEP_TYPE_OVER) &&
-+			    (thr->heap->dbg_step_thread == thr) &&
-+			    (thr->heap->dbg_step_csindex == thr->callstack_top - 1) &&
-+			    (line != thr->heap->dbg_step_startline)) {
-+				DUK_D(DUK_DPRINT("STEP STATE TRIGGERED PAUSE at line %ld",
-+				                 (long) line));
-+
-+				DUK_HEAP_SET_PAUSED(thr->heap);
-+			}
-+
-+			/* Check for breakpoints only on line transition.
-+			 * Breakpoint is triggered when we enter or cross
-+			 * the target line, and the previous line was within
-+			 * the same function.
-+			 */
-+			bp_active = thr->heap->dbg_breakpoints_active;
-+			for (;;) {
-+				bp = *bp_active++;
-+				if (bp == NULL) {
-+					break;
-+				}
-+				DUK_ASSERT(bp->filename != NULL);
-+				if (act->prev_line < bp->line && line >= bp->line) {
-+					DUK_D(DUK_DPRINT("BREAKPOINT TRIGGERED at %!O:%ld",
-+					                 (duk_heaphdr *) bp->filename, (long) bp->line));
-+
-+					DUK_HEAP_SET_PAUSED(thr->heap);
-+				}
-+			}
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("PC=%ld line=%ld", (long) act->pc, (long) line));
-+		}
-+
-+		act->prev_line = line;
-+	}
-+
-+	/*
-+	 *  Rate limit check for sending status update or peeking into
-+	 *  the debug transport.  Both can be expensive operations that
-+	 *  we don't want to do on every opcode.
-+	 *
-+	 *  Making sure the interval remains reasonable on a wide variety
-+	 *  of targets and bytecode is difficult without a timestamp, so
-+	 *  we use a Date-provided timestamp for the rate limit check.
-+	 *  But since it's also expensive to get a timestamp, a bytecode
-+	 *  counter is used to rate limit getting timestamps.
-+	 */
-+
-+	if (thr->heap->dbg_state_dirty || thr->heap->dbg_paused) {
-+		send_status = 1;
-+	} else {
-+		send_status = 0;
-+	}
-+
-+	if (thr->heap->dbg_paused) {
-+		process_messages = 1;
-+	} else {
-+		process_messages = 0;
-+	}
-+
-+	thr->heap->dbg_exec_counter += thr->heap->interrupt_init;
-+	if (thr->heap->dbg_exec_counter - thr->heap->dbg_last_counter >= DUK_HEAP_DBG_RATELIMIT_OPCODES) {
-+		/* Overflow of the execution counter is fine and doesn't break
-+		 * anything here.
-+		 */
-+
-+		duk_double_t now, diff_last;
-+
-+		thr->heap->dbg_last_counter = thr->heap->dbg_exec_counter;
-+		now = duk_bi_date_get_now(ctx);
-+
-+		diff_last = now - thr->heap->dbg_last_time;
-+		if (diff_last < 0.0 || diff_last >= (duk_double_t) DUK_HEAP_DBG_RATELIMIT_MILLISECS) {
-+			/* Negative value checked so that a "time jump" works
-+			 * reasonably.
-+			 *
-+			 * Same interval is now used for status sending and
-+			 * peeking.
-+			 */
-+
-+			thr->heap->dbg_last_time = now;
-+			send_status = 1;
-+			process_messages = 1;
-+		}
-+	}
-+
-+	/*
-+	 *  Send status
-+	 */
-+
-+	act = NULL;  /* may be changed */
-+	if (send_status) {
-+		duk_debug_send_status(thr);
-+		thr->heap->dbg_state_dirty = 0;
-+	}
-+
-+	/*
-+	 *  Process messages.  If we're paused, we'll block for new messages.
-+	 *  if we're not paused, we'll process anything we can peek but won't
-+	 *  block for more.
-+	 */
-+
-+	if (process_messages) {
-+		processed_messages = duk_debug_process_messages(thr, 0 /*no_block*/);
-+	}
-+
-+	/* XXX: any case here where we need to re-send status? */
-+
-+	/* Continue checked execution if there are breakpoints or we're stepping.
-+	 * Also use checked execution if paused flag is active - it shouldn't be
-+	 * because the debug message loop shouldn't terminate if it was.  Step out
-+	 * is handled by callstack unwind and doesn't need checked execution.
-+	 * Note that debugger may have detached due to error or explicit request
-+	 * above, so we must recheck attach status.
-+	 */
-+
-+	if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
-+		act = thr->callstack + thr->callstack_top - 1;  /* relookup, may have changed */
-+		if (act->flags & DUK_ACT_FLAG_BREAKPOINT_ACTIVE ||
-+		    ((thr->heap->dbg_step_type == DUK_STEP_TYPE_INTO ||
-+		      thr->heap->dbg_step_type == DUK_STEP_TYPE_OVER) &&
-+		     thr->heap->dbg_step_thread == thr &&
-+		     thr->heap->dbg_step_csindex == thr->callstack_top - 1) ||
-+		     thr->heap->dbg_paused) {
-+			*out_immediate = 1;
-+		}
-+
-+		/* If we processed any debug messages breakpoints may have
-+		 * changed; restart execution to re-check active breakpoints.
-+		 */
-+		if (processed_messages) {
-+			DUK_D(DUK_DPRINT("processed debug messages, restart execution to recheck possibly changed breakpoints"));
-+			*out_interrupt_retval = DUK__INT_RESTART;
-+		}
-+	} else {
-+		DUK_D(DUK_DPRINT("debugger became detached, resume normal execution"));
-+	}
-+}
-+#endif  /* DUK_USE_DEBUGGER_SUPPORT */
-+
-+DUK_LOCAL duk_small_uint_t duk__executor_interrupt(duk_hthread *thr) {
-+	duk_int_t ctr;
-+	duk_activation *act;
-+	duk_hcompiledfunction *fun;
-+	duk_bool_t immediate = 0;
-+	duk_small_uint_t retval;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->callstack != NULL);
-+	DUK_ASSERT(thr->callstack_top > 0);
-+
-+	retval = DUK__INT_NOACTION;
-+	ctr = DUK_HEAP_INTCTR_DEFAULT;
-+
-+	/*
-+	 *  Avoid nested calls.  Concretely this happens during debugging, e.g.
-+	 *  when we eval() an expression.
-+	 */
-+
-+	if (DUK_HEAP_HAS_INTERRUPT_RUNNING(thr->heap)) {
-+		DUK_DD(DUK_DDPRINT("nested executor interrupt, ignoring"));
-+
-+		/* Set a high interrupt counter; the original executor
-+		 * interrupt invocation will rewrite before exiting.
-+		 */
-+		thr->heap->interrupt_init = ctr;
-+		thr->heap->interrupt_counter = ctr - 1;
-+		thr->interrupt_counter = ctr - 1;
-+		return DUK__INT_NOACTION;
-+	}
-+	DUK_HEAP_SET_INTERRUPT_RUNNING(thr->heap);
-+
-+	act = thr->callstack + thr->callstack_top - 1;
-+	fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act);
-+	DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION((duk_hobject *) fun));
-+	DUK_UNREF(fun);
-+
-+#if defined(DUK_USE_EXEC_TIMEOUT_CHECK)
-+	/*
-+	 *  Execution timeout check
-+	 */
-+
-+	if (DUK_USE_EXEC_TIMEOUT_CHECK(thr->heap->heap_udata)) {
-+		/* Keep throwing an error whenever we get here.  The unusual values
-+		 * are set this way because no instruction is ever executed, we just
-+		 * throw an error until all try/catch/finally and other catchpoints
-+		 * have been exhausted.  Duktape/C code gets control at each protected
-+		 * call but whenever it enters back into Duktape the RangeError gets
-+		 * raised.  User exec timeout check must consistently indicate a timeout
-+		 * until we've fully bubbled out of Duktape.
-+		 */
-+		DUK_D(DUK_DPRINT("execution timeout, throwing a RangeError"));
-+		thr->heap->interrupt_init = 0;
-+		thr->heap->interrupt_counter = 0;
-+		thr->interrupt_counter = 0;
-+		DUK_HEAP_CLEAR_INTERRUPT_RUNNING(thr->heap);
-+		DUK_ERROR(thr, DUK_ERR_RANGE_ERROR, "execution timeout");
-+	}
-+#endif  /* DUK_USE_EXEC_TIMEOUT_CHECK */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
-+		duk__interrupt_handle_debugger(thr, &immediate, &retval);
-+		act = thr->callstack + thr->callstack_top - 1;  /* relookup if changed */
-+	}
-+#endif  /* DUK_USE_DEBUGGER_SUPPORT */
-+
-+	/*
-+	 *  Update the interrupt counter
-+	 */
-+
-+	if (immediate) {
-+		/* Cause an interrupt after executing one instruction. */
-+		ctr = 1;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("executor interrupt finished, cstop=%ld, pc=%ld, nextctr=%ld",
-+	                     (long) thr->callstack_top, (long) act->pc, (long) ctr));
-+
-+	/* The counter value is one less than the init value: init value should
-+	 * indicate how many instructions are executed before interrupt.  To
-+	 * execute 1 instruction, counter must be 0.
-+	 */
-+	thr->heap->interrupt_init = ctr;
-+	thr->heap->interrupt_counter = ctr - 1;
-+	thr->interrupt_counter = ctr - 1;
-+	DUK_HEAP_CLEAR_INTERRUPT_RUNNING(thr->heap);
-+
-+	return retval;
-+}
-+#endif  /* DUK_USE_INTERRUPT_COUNTER */
-+
-+/*
-+ *  Debugger handling for executor restart
-+ *
-+ *  Check for breakpoints, stepping, etc, and figure out if we should execute
-+ *  in checked or normal mode.  Note that we can't do this when an activation
-+ *  is created, because breakpoint status (and stepping status) may change
-+ *  later, so we must recheck every time we're executing an activation.
-+ */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+DUK_LOCAL void duk__executor_handle_debugger(duk_hthread *thr, duk_activation *act, duk_hcompiledfunction *fun) {
-+	duk_heap *heap;
-+	duk_tval *tv_tmp;
-+	duk_hstring *filename;
-+	duk_small_uint_t bp_idx;
-+	duk_breakpoint **bp_active;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(act != NULL);
-+	DUK_ASSERT(fun != NULL);
-+
-+	heap = thr->heap;
-+	bp_active = heap->dbg_breakpoints_active;
-+	act->flags &= ~DUK_ACT_FLAG_BREAKPOINT_ACTIVE;
-+
-+	tv_tmp = duk_hobject_find_existing_entry_tval_ptr(thr->heap, (duk_hobject *) fun, DUK_HTHREAD_STRING_FILE_NAME(thr));
-+	if (tv_tmp && DUK_TVAL_IS_STRING(tv_tmp)) {
-+		filename = DUK_TVAL_GET_STRING(tv_tmp);
-+
-+		/* Figure out all active breakpoints.  A breakpoint is
-+		 * considered active if the current function's fileName
-+		 * matches the breakpoint's fileName, AND there is no
-+		 * inner function that has matching line numbers
-+		 * (otherwise a breakpoint would be triggered both
-+		 * inside and outside of the inner function which would
-+		 * be confusing).  Example:
-+		 *
-+		 *     function foo() {
-+		 *         print('foo');
-+		 *         function bar() {    <-.  breakpoints in these
-+		 *             print('bar');     |  lines should not affect
-+		 *         }                   <-'  foo() execution
-+		 *         bar();
-+		 *     }
-+		 *
-+		 * We need a few things that are only available when
-+		 * debugger support is enabled: (1) a line range for
-+		 * each function, and (2) access to the function
-+		 * template to access the inner functions (and their
-+		 * line ranges).
-+		 *
-+		 * It's important to have a narrow match for active
-+		 * breakpoints so that we don't enter checked execution
-+		 * when that's not necessary.  For instance, if we're
-+		 * running inside a certain function and there's
-+		 * breakpoint outside in (after the call site), we
-+		 * don't want to slow down execution of the function.
-+		 */
-+
-+		for (bp_idx = 0; bp_idx < heap->dbg_breakpoint_count; bp_idx++) {
-+			duk_breakpoint *bp = heap->dbg_breakpoints + bp_idx;
-+			duk_hobject **funcs, **funcs_end;
-+			duk_hcompiledfunction *inner_fun;
-+			duk_bool_t bp_match;
-+
-+			if (bp->filename == filename &&
-+			    bp->line >= fun->start_line && bp->line <= fun->end_line) {
-+				bp_match = 1;
-+				DUK_DD(DUK_DDPRINT("breakpoint filename and line match: "
-+				                   "%s:%ld vs. %s (line %ld vs. %ld-%ld)",
-+				                   DUK_HSTRING_GET_DATA(bp->filename),
-+				                   (long) bp->line,
-+				                   DUK_HSTRING_GET_DATA(filename),
-+				                   (long) bp->line,
-+				                   (long) fun->start_line,
-+				                   (long) fun->end_line));
-+
-+				funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun);
-+				funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, fun);
-+				while (funcs != funcs_end) {
-+					inner_fun = (duk_hcompiledfunction *) *funcs;
-+					DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) inner_fun));
-+					if (bp->line >= inner_fun->start_line && bp->line <= inner_fun->end_line) {
-+						DUK_DD(DUK_DDPRINT("inner function masks ('captures') breakpoint"));
-+						bp_match = 0;
-+						break;
-+					}
-+					funcs++;
-+				}
-+
-+				if (bp_match) {
-+					/* No need to check for size of bp_active list,
-+					 * it's always larger than maximum number of
-+					 * breakpoints.
-+					 */
-+					act->flags |= DUK_ACT_FLAG_BREAKPOINT_ACTIVE;
-+					*bp_active = heap->dbg_breakpoints + bp_idx;
-+					bp_active++;
-+				}
-+			}
-+		}
-+	}
-+
-+	*bp_active = NULL;  /* terminate */
-+
-+	DUK_DD(DUK_DDPRINT("ACTIVE BREAKPOINTS: %ld", (long) (bp_active - thr->heap->dbg_breakpoints_active)));
-+
-+	/* Force pause if we were doing "step into" in another activation. */
-+	if (thr->heap->dbg_step_thread != NULL &&
-+	    thr->heap->dbg_step_type == DUK_STEP_TYPE_INTO &&
-+	    (thr->heap->dbg_step_thread != thr ||
-+	     thr->heap->dbg_step_csindex != thr->callstack_top - 1)) {
-+		DUK_D(DUK_DPRINT("STEP INTO ACTIVE, FORCE PAUSED"));
-+		DUK_HEAP_SET_PAUSED(thr->heap);
-+	}
-+
-+	/* Force interrupt right away if we're paused or in "checked mode".
-+	 * Step out is handled by callstack unwind.
-+	 */
-+	if (act->flags & (DUK_ACT_FLAG_BREAKPOINT_ACTIVE) ||
-+	    thr->heap->dbg_paused ||
-+	    (thr->heap->dbg_step_type != DUK_STEP_TYPE_OUT &&
-+	     thr->heap->dbg_step_csindex == thr->callstack_top - 1)) {
-+		thr->interrupt_counter = 0;
-+	}
-+}
-+#endif  /* DUK_USE_DEBUGGER_SUPPORT */
-+
-+/*
-+ *  Ecmascript bytecode executor.
-+ *
-+ *  Resume execution for the current thread from its current activation.
-+ *  Returns when execution would return from the entry level activation,
-+ *  leaving a single return value on top of the stack.  Function calls
-+ *  and thread resumptions are handled internally.  If an error occurs,
-+ *  a longjmp() with type DUK_LJ_TYPE_THROW is called on the entry level
-+ *  setjmp() jmpbuf.
-+ *
-+ *  Ecmascript function calls and coroutine resumptions are handled
-+ *  internally without recursive C calls.  Other function calls are
-+ *  handled using duk_handle_call(), increasing C recursion depth.
-+ *
-+ *  There are many other tricky control flow situations, such as:
-+ *
-+ *    - Break and continue (fast and slow)
-+ *    - Return (fast and slow)
-+ *    - Error throwing
-+ *    - Thread resume and yield
-+ *
-+ *  For more detailed notes, see doc/execution.rst.
-+ *
-+ *  Also see doc/code-issues.rst for discussion of setjmp(), longjmp(),
-+ *  and volatile.
-+ */
-+
-+#define DUK__STRICT()       (DUK_HOBJECT_HAS_STRICT(&(fun)->obj))
-+#define DUK__REG(x)         (thr->valstack_bottom[(x)])
-+#define DUK__REGP(x)        (&thr->valstack_bottom[(x)])
-+#define DUK__CONST(x)       (DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun)[(x)])
-+#define DUK__CONSTP(x)      (&DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun)[(x)])
-+#define DUK__REGCONST(x)    ((x) < DUK_BC_REGLIMIT ? DUK__REG((x)) : DUK__CONST((x) - DUK_BC_REGLIMIT))
-+#define DUK__REGCONSTP(x)   ((x) < DUK_BC_REGLIMIT ? DUK__REGP((x)) : DUK__CONSTP((x) - DUK_BC_REGLIMIT))
-+
-+#ifdef DUK_USE_VERBOSE_EXECUTOR_ERRORS
-+#define DUK__INTERNAL_ERROR(msg)  do { \
-+		DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, (msg)); \
-+	} while (0)
-+#else
-+#define DUK__INTERNAL_ERROR(msg)  do { \
-+		goto internal_error; \
-+	} while (0)
-+#endif
-+
-+DUK_INTERNAL void duk_js_execute_bytecode(duk_hthread *exec_thr) {
-+	/* Entry level info.  Although these are assigned to before setjmp()
-+	 * a 'volatile' seems to be needed.  Note placement of "volatile" for
-+	 * pointers.  See doc/code-issues.rst for more discussion.
-+	 */
-+	duk_hthread * volatile entry_thread;   /* volatile copy of exec_thr */
-+	volatile duk_size_t entry_callstack_top;
-+	volatile duk_int_t entry_call_recursion_depth;
-+	duk_jmpbuf * volatile entry_jmpbuf_ptr;
-+
-+	/* "hot" variables for interpretation -- not volatile, value not guaranteed in setjmp error handling */
-+	duk_hthread *thr;             /* stable */
-+	duk_activation *act;          /* semi-stable (ok as long as callstack not resized) */
-+	duk_hcompiledfunction *fun;   /* stable */
-+	duk_instr_t *bcode;           /* stable */
-+	/* 'consts' is computed on-the-fly */
-+	/* 'funcs' is quite rarely used, so no local for it */
-+
-+	/* "hot" temps for interpretation -- not volatile, value not guaranteed in setjmp error handling */
-+	duk_uint_fast32_t ins;  /* XXX: check performance impact on x64 between fast/non-fast variant */
-+
-+	/* jmpbuf */
-+	duk_jmpbuf jmpbuf;
-+
-+#ifdef DUK_USE_INTERRUPT_COUNTER
-+	duk_int_t int_ctr;
-+#endif
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	duk_size_t valstack_top_base;    /* valstack top, should match before interpreting each op (no leftovers) */
-+#endif
-+
-+	/* XXX: document assumptions on setjmp and volatile variables
-+	 * (see duk_handle_call()).
-+	 */
-+
-+	/*
-+	 *  Preliminaries
-+	 */
-+
-+	DUK_ASSERT(exec_thr != NULL);
-+	DUK_ASSERT(exec_thr->heap != NULL);
-+	DUK_ASSERT(exec_thr->heap->curr_thread != NULL);
-+	DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR((duk_heaphdr *) exec_thr);
-+	DUK_ASSERT(exec_thr->callstack_top >= 1);  /* at least one activation, ours */
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1) != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(exec_thr->callstack + exec_thr->callstack_top - 1)));
-+
-+	entry_thread = exec_thr;  /* volatile copy */
-+	thr = (duk_hthread *) entry_thread;
-+	entry_callstack_top = thr->callstack_top;
-+	entry_call_recursion_depth = thr->heap->call_recursion_depth;
-+	entry_jmpbuf_ptr = thr->heap->lj.jmpbuf_ptr;
-+
-+	/*
-+	 *  Setjmp catchpoint setup.
-+	 *
-+	 *  Note: we currently assume that the setjmp() catchpoint is
-+	 *  not re-entrant (longjmp() cannot be called more than once
-+	 *  for a single setjmp()).
-+	 */
-+
-+ reset_setjmp_catchpoint:
-+
-+	DUK_ASSERT(thr != NULL);
-+	thr->heap->lj.jmpbuf_ptr = &jmpbuf;
-+	DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);
-+
-+	if (DUK_SETJMP(thr->heap->lj.jmpbuf_ptr->jb)) {
-+		/*
-+		 *  Note: any local variables accessed here must have their value
-+		 *  assigned *before* the setjmp() call, OR they must be declared
-+		 *  volatile.  Otherwise their value is not guaranteed to be correct.
-+		 *
-+		 *  'thr' might seem to be a risky variable because it is changed
-+		 *  for yield and resume.  However, yield and resume are handled
-+		 *  using longjmp()s.
-+		 */
-+
-+		duk_small_uint_t lj_ret;
-+
-+		DUK_DDD(DUK_DDDPRINT("longjmp caught by bytecode executor"));
-+
-+		/* Relookup 'thr': it's not volatile so its value is not
-+		 * guaranteed.  The heap->curr_thread value should always be
-+		 * valid here because longjmp callers don't switch threads,
-+		 * only the longjmp handler does that (even for RESUME and
-+		 * YIELD).
-+		 */
-+		DUK_ASSERT(entry_thread != NULL);
-+		thr = entry_thread->heap->curr_thread;
-+
-+		/* XXX: signalling the need to shrink check (only if unwound) */
-+
-+		/* Must be restored here to handle e.g. yields properly. */
-+		thr->heap->call_recursion_depth = entry_call_recursion_depth;
-+
-+		/* Switch to caller's setjmp() catcher so that if an error occurs
-+		 * during error handling, it is always propagated outwards instead
-+		 * of causing an infinite loop in our own handler.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("restore jmpbuf_ptr: %p -> %p",
-+		                     (void *) ((thr && thr->heap) ? thr->heap->lj.jmpbuf_ptr : NULL),
-+		                     (void *) entry_jmpbuf_ptr));
-+		thr->heap->lj.jmpbuf_ptr = (duk_jmpbuf *) entry_jmpbuf_ptr;
-+
-+		lj_ret = duk__handle_longjmp(thr, (duk_hthread *) entry_thread, (duk_size_t) entry_callstack_top);
-+
-+		if (lj_ret == DUK__LONGJMP_RESTART) {
-+			/*
-+			 *  Restart bytecode execution, possibly with a changed thread.
-+			 */
-+			thr = thr->heap->curr_thread;
-+			goto reset_setjmp_catchpoint;
-+		} else if (lj_ret == DUK__LONGJMP_RETHROW) {
-+			/*
-+			 *  Rethrow error to calling state.
-+			 */
-+
-+			/* thread may have changed (e.g. YIELD converted to THROW) */
-+			thr = thr->heap->curr_thread;
-+
-+			DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr);
-+
-+			duk_err_longjmp(thr);
-+			DUK_UNREACHABLE();
-+		} else {
-+			/*
-+			 *  Return from bytecode executor with a return value.
-+			 */
-+			DUK_ASSERT(lj_ret == DUK__LONGJMP_FINISHED);
-+
-+			/* XXX: return assertions for valstack, callstack, catchstack */
-+
-+			DUK_ASSERT(thr->heap->lj.jmpbuf_ptr == entry_jmpbuf_ptr);
-+			return;
-+		}
-+		DUK_UNREACHABLE();
-+	}
-+
-+	/*
-+	 *  Restart execution by reloading thread state.
-+	 *
-+	 *  Note that 'thr' and any thread configuration may have changed,
-+	 *  so all local variables are suspect.
-+	 *
-+	 *  The number of local variables should be kept to a minimum: if
-+	 *  the variables are spilled, they will need to be loaded from
-+	 *  memory anyway.
-+	 */
-+
-+ restart_execution:
-+
-+	/* Lookup current thread; use the volatile 'entry_thread' for this to
-+	 * avoid clobber warnings.  (Any valid, reachable 'thr' value would be
-+	 * fine for this, so using 'entry_thread' is just to silence warnings.)
-+	 */
-+	thr = entry_thread->heap->curr_thread;
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(thr->callstack_top >= 1);
-+	DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
-+
-+#ifdef DUK_USE_INTERRUPT_COUNTER
-+	thr->interrupt_counter = thr->heap->interrupt_counter;
-+#endif
-+
-+	/* assume that thr->valstack_bottom has been set-up before getting here */
-+	act = thr->callstack + thr->callstack_top - 1;
-+	fun = (duk_hcompiledfunction *) DUK_ACT_GET_FUNC(act);
-+	DUK_ASSERT(fun != NULL);
-+	DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs);
-+	bcode = DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, fun);
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap) && !thr->heap->dbg_processing) {
-+		thr->heap->dbg_processing = 1;
-+		duk__executor_handle_debugger(thr, act, fun);
-+		thr->heap->dbg_processing = 0;
-+	}
-+#endif  /* DUK_USE_DEBUGGER_SUPPORT */
-+
-+	/* XXX: shrink check flag? */
-+
-+	/*
-+	 *  Bytecode interpreter.
-+	 *
-+	 *  The interpreter must be very careful with memory pointers, as
-+	 *  many pointers are not guaranteed to be 'stable' and may be
-+	 *  reallocated and relocated on-the-fly quite easily (e.g. by a
-+	 *  memory allocation or a property access).
-+	 *
-+	 *  The following are assumed to have stable pointers:
-+	 *    - the current thread
-+	 *    - the current function
-+	 *    - the bytecode, constant table, inner function table of the
-+	 *      current function (as they are a part of the function allocation)
-+	 *
-+	 *  The following are assumed to have semi-stable pointers:
-+	 *    - the current activation entry: stable as long as callstack
-+	 *      is not changed (reallocated by growing or shrinking), or
-+	 *      by any garbage collection invocation (through finalizers)
-+	 *    - Note in particular that ANY DECREF can invalidate the
-+	 *      activation pointer
-+	 *
-+	 *  The following are not assumed to have stable pointers at all:
-+	 *    - the value stack (registers) of the current thread
-+	 *    - the catch stack of the current thread
-+	 *
-+	 *  See execution.txt for discussion.
-+	 */
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(act != NULL);
-+	DUK_ASSERT(fun != NULL);
-+	DUK_ASSERT(bcode != NULL);
-+
-+	DUK_DD(DUK_DDPRINT("restarting execution, thr %p, act %p (idx %ld), fun %p, bcode %p, "
-+	                   "consts %p, funcs %p, lev %ld, regbot %ld, regtop %ld, catchstack_top=%ld, "
-+	                   "preventcount=%ld",
-+	                   (void *) thr,
-+	                   (void *) act,
-+	                   (long) (thr->callstack_top - 1),
-+	                   (void *) fun,
-+	                   (void *) bcode,
-+	                   (void *) DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, fun),
-+	                   (void *) DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun),
-+	                   (long) (thr->callstack_top - 1),
-+	                   (long) (thr->valstack_bottom - thr->valstack),
-+	                   (long) (thr->valstack_top - thr->valstack),
-+	                   (long) thr->catchstack_top,
-+	                   (long) thr->callstack_preventcount));
-+
-+#ifdef DUK_USE_ASSERTIONS
-+	valstack_top_base = (duk_size_t) (thr->valstack_top - thr->valstack);
-+#endif
-+
-+	for (;;) {
-+		DUK_ASSERT(thr->callstack_top >= 1);
-+		DUK_ASSERT(thr->valstack_top - thr->valstack_bottom == fun->nregs);
-+		DUK_ASSERT((duk_size_t) (thr->valstack_top - thr->valstack) == valstack_top_base);
-+
-+		/* Executor interrupt counter check, used to implement breakpoints,
-+		 * debugging interface, execution timeouts, etc.  The counter is heap
-+		 * specific but is maintained in the current thread to make the check
-+		 * as fast as possible.  The counter is copied back to the heap struct
-+		 * whenever a thread switch occurs by the DUK_HEAP_SWITCH_THREAD() macro.
-+		 */
-+#ifdef DUK_USE_INTERRUPT_COUNTER
-+		int_ctr = thr->interrupt_counter;
-+		if (DUK_LIKELY(int_ctr > 0)) {
-+			thr->interrupt_counter = int_ctr - 1;
-+		} else {
-+			/* Trigger at zero or below */
-+			duk_small_uint_t exec_int_ret;
-+
-+			exec_int_ret = duk__executor_interrupt(thr);
-+			if (exec_int_ret == DUK__INT_RESTART) {
-+				goto restart_execution;
-+			}
-+		}
-+#endif
-+
-+		/* Because ANY DECREF potentially invalidates 'act' now (through
-+		 * finalization), we need to re-lookup 'act' in almost every case.
-+		 *
-+		 * XXX: future work for performance optimization:
-+		 * This is not nice; it would be nice if the program counter was a
-+		 * behind a stable pointer.  For instance, put a raw bytecode pointer
-+		 * into duk_hthread struct (not into the callstack); since bytecode
-+		 * has a stable pointer this would work nicely.  Whenever a call is
-+		 * made, the bytecode pointer could be backed up as an integer index
-+		 * to the calling activation.  Perhaps add a macro for setting up a
-+		 * new activation (same as for setting up / switching threads)?
-+		 */
-+
-+		act = thr->callstack + thr->callstack_top - 1;
-+		DUK_ASSERT(bcode + act->pc >= DUK_HCOMPILEDFUNCTION_GET_CODE_BASE(thr->heap, fun));
-+		DUK_ASSERT(bcode + act->pc < DUK_HCOMPILEDFUNCTION_GET_CODE_END(thr->heap, fun));
-+
-+		DUK_DDD(DUK_DDDPRINT("executing bytecode: pc=%ld ins=0x%08lx, op=%ld, valstack_top=%ld/%ld, nregs=%ld  -->  %!I",
-+		                     (long) act->pc,
-+		                     (unsigned long) bcode[act->pc],
-+		                     (long) DUK_DEC_OP(bcode[act->pc]),
-+		                     (long) (thr->valstack_top - thr->valstack),
-+		                     (long) (thr->valstack_end - thr->valstack),
-+		                     (long) (fun ? fun->nregs : -1),
-+		                     (duk_instr_t) bcode[act->pc]));
-+
-+#if defined(DUK_USE_ASSERTIONS)
-+		/* Quite heavy assert: check that valstack is in correctly
-+		 * initialized state.  Improper shuffle instructions can
-+		 * write beyond valstack_end so this check catches them in
-+		 * the act.
-+		 */
-+		{
-+			duk_tval *tv;
-+			tv = thr->valstack_top;
-+			while (tv != thr->valstack_end) {
-+				DUK_ASSERT(DUK_TVAL_IS_UNDEFINED_UNUSED(tv));
-+				tv++;
-+			}
-+		}
-+#endif
-+
-+		ins = bcode[act->pc++];
-+
-+		/* Typing: use duk_small_(u)int_fast_t when decoding small
-+		 * opcode fields (op, A, B, C) and duk_(u)int_fast_t when
-+		 * decoding larger fields (e.g. BC which is 18 bits).  Use
-+		 * unsigned variant by default, signed when the value is used
-+		 * in signed arithmetic.  Using variable names such as 'a', 'b',
-+		 * 'c', 'bc', etc makes it easier to spot typing mismatches.
-+		 */
-+
-+		/* XXX: the best typing needs to be validated by perf measurement:
-+		 * e.g. using a small type which is the cast to a larger duk_idx_t
-+		 * may be slower than declaring the variable as a duk_idx_t in the
-+		 * first place.
-+		 */
-+
-+		/* XXX: use macros for the repetitive tval/refcount handling. */
-+
-+		switch ((int) DUK_DEC_OP(ins)) {
-+		/* XXX: switch cast? */
-+
-+		case DUK_OP_LDREG: {
-+			duk_small_uint_fast_t a;
-+			duk_uint_fast_t bc;
-+			duk_tval tv_tmp;
-+			duk_tval *tv1, *tv2;
-+
-+			a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
-+			bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+			DUK_TVAL_SET_TVAL(tv1, tv2);
-+			DUK_TVAL_INCREF(thr, tv1);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+			break;
-+		}
-+
-+		case DUK_OP_STREG: {
-+			duk_small_uint_fast_t a;
-+			duk_uint_fast_t bc;
-+			duk_tval tv_tmp;
-+			duk_tval *tv1, *tv2;
-+
-+			a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
-+			bc = DUK_DEC_BC(ins); tv2 = DUK__REGP(bc);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv2);
-+			DUK_TVAL_SET_TVAL(tv2, tv1);
-+			DUK_TVAL_INCREF(thr, tv2);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+			break;
-+		}
-+
-+		case DUK_OP_LDCONST: {
-+			duk_small_uint_fast_t a;
-+			duk_uint_fast_t bc;
-+			duk_tval tv_tmp;
-+			duk_tval *tv1, *tv2;
-+
-+			a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
-+			bc = DUK_DEC_BC(ins); tv2 = DUK__CONSTP(bc);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+			DUK_TVAL_SET_TVAL(tv1, tv2);
-+			DUK_TVAL_INCREF(thr, tv2);  /* may be e.g. string */
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+			break;
-+		}
-+
-+		case DUK_OP_LDINT: {
-+			duk_small_uint_fast_t a;
-+			duk_int_fast_t bc;
-+			duk_tval tv_tmp;
-+			duk_tval *tv1;
-+#if defined(DUK_USE_FASTINT)
-+			duk_int32_t val;
-+#else
-+			duk_double_t val;
-+#endif
-+
-+#if defined(DUK_USE_FASTINT)
-+			a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
-+			bc = DUK_DEC_BC(ins); val = (duk_int32_t) (bc - DUK_BC_LDINT_BIAS);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+			DUK_TVAL_SET_FASTINT_I32(tv1, val);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+#else
-+			a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
-+			bc = DUK_DEC_BC(ins); val = (duk_double_t) (bc - DUK_BC_LDINT_BIAS);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+			DUK_TVAL_SET_NUMBER(tv1, val);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+#endif
-+			break;
-+		}
-+
-+		case DUK_OP_LDINTX: {
-+			duk_small_uint_fast_t a;
-+			duk_tval *tv1;
-+			duk_double_t val;
-+
-+			/* LDINTX is not necessarily in FASTINT range, so
-+			 * no fast path for now.
-+			 *
-+			 * XXX: perhaps restrict LDINTX to fastint range, wider
-+			 * range very rarely needed.
-+			 */
-+
-+			a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
-+			val = DUK_TVAL_GET_NUMBER(tv1) * ((duk_double_t) (1L << DUK_BC_LDINTX_SHIFT)) +
-+			      (duk_double_t) DUK_DEC_BC(ins);
-+#if defined(DUK_USE_FASTINT)
-+			DUK_TVAL_SET_NUMBER_CHKFAST(tv1, val);
-+#else
-+			DUK_TVAL_SET_NUMBER(tv1, val);
-+#endif
-+			break;
-+		}
-+
-+		case DUK_OP_MPUTOBJ:
-+		case DUK_OP_MPUTOBJI: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a;
-+			duk_tval *tv1;
-+			duk_hobject *obj;
-+			duk_uint_fast_t idx;
-+			duk_small_uint_fast_t count;
-+
-+			/* A -> register of target object
-+			 * B -> first register of key/value pair list
-+			 * C -> number of key/value pairs
-+			 */
-+
-+			a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
-+			DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1));
-+			obj = DUK_TVAL_GET_OBJECT(tv1);
-+
-+			idx = (duk_uint_fast_t) DUK_DEC_B(ins);
-+			if (DUK_DEC_OP(ins) == DUK_OP_MPUTOBJI) {
-+				duk_tval *tv_ind = DUK__REGP(idx);
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
-+				idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
-+			}
-+
-+			count = (duk_small_uint_fast_t) DUK_DEC_C(ins);
-+
-+#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
-+			if (DUK_UNLIKELY(idx + count * 2 > (duk_uint_fast_t) duk_get_top(ctx))) {
-+				/* XXX: use duk_is_valid_index() instead? */
-+				/* XXX: improve check; check against nregs, not against top */
-+				DUK__INTERNAL_ERROR("MPUTOBJ out of bounds");
-+			}
-+#endif
-+
-+			duk_push_hobject(ctx, obj);
-+
-+			while (count > 0) {
-+				/* XXX: faster initialization (direct access or better primitives) */
-+
-+				duk_push_tval(ctx, DUK__REGP(idx));
-+				DUK_ASSERT(duk_is_string(ctx, -1));
-+				duk_push_tval(ctx, DUK__REGP(idx + 1));  /* -> [... obj key value] */
-+				duk_xdef_prop_wec(ctx, -3);              /* -> [... obj] */
-+
-+				count--;
-+				idx += 2;
-+			}
-+
-+			duk_pop(ctx);  /* [... obj] -> [...] */
-+			break;
-+		}
-+
-+		case DUK_OP_MPUTARR:
-+		case DUK_OP_MPUTARRI: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a;
-+			duk_tval *tv1;
-+			duk_hobject *obj;
-+			duk_uint_fast_t idx;
-+			duk_small_uint_fast_t count;
-+			duk_uint32_t arr_idx;
-+
-+			/* A -> register of target object
-+			 * B -> first register of value data (start_index, value1, value2, ..., valueN)
-+			 * C -> number of key/value pairs (N)
-+			 */
-+
-+			a = DUK_DEC_A(ins); tv1 = DUK__REGP(a);
-+			DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1));
-+			obj = DUK_TVAL_GET_OBJECT(tv1);
-+			DUK_ASSERT(obj != NULL);
-+
-+			idx = (duk_uint_fast_t) DUK_DEC_B(ins);
-+			if (DUK_DEC_OP(ins) == DUK_OP_MPUTARRI) {
-+				duk_tval *tv_ind = DUK__REGP(idx);
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
-+				idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
-+			}
-+
-+			count = (duk_small_uint_fast_t) DUK_DEC_C(ins);
-+
-+#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
-+			if (idx + count + 1 > (duk_uint_fast_t) duk_get_top(ctx)) {
-+				/* XXX: use duk_is_valid_index() instead? */
-+				/* XXX: improve check; check against nregs, not against top */
-+				DUK__INTERNAL_ERROR("MPUTARR out of bounds");
-+			}
-+#endif
-+
-+			tv1 = DUK__REGP(idx);
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
-+			arr_idx = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv1);
-+			idx++;
-+
-+			duk_push_hobject(ctx, obj);
-+
-+			while (count > 0) {
-+				/* duk_xdef_prop() will define an own property without any array
-+				 * special behaviors.  We'll need to set the array length explicitly
-+				 * in the end.  For arrays with elisions, the compiler will emit an
-+				 * explicit SETALEN which will update the length.
-+				 */
-+
-+				/* XXX: because we're dealing with 'own' properties of a fresh array,
-+				 * the array initializer should just ensure that the array has a large
-+				 * enough array part and write the values directly into array part,
-+				 * and finally set 'length' manually in the end (as already happens now).
-+				 */
-+
-+				duk_push_tval(ctx, DUK__REGP(idx));          /* -> [... obj value] */
-+				duk_xdef_prop_index_wec(ctx, -2, arr_idx);   /* -> [... obj] */
-+
-+				/* XXX: could use at least one fewer loop counters */
-+				count--;
-+				idx++;
-+				arr_idx++;
-+			}
-+
-+			/* XXX: E5.1 Section 11.1.4 coerces the final length through
-+			 * ToUint32() which is odd but happens now as a side effect of
-+			 * 'arr_idx' type.
-+			 */
-+			duk_hobject_set_length(thr, obj, (duk_uint32_t) arr_idx);
-+
-+			duk_pop(ctx);  /* [... obj] -> [...] */
-+			break;
-+		}
-+
-+		case DUK_OP_NEW:
-+		case DUK_OP_NEWI: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_uint_fast_t idx;
-+			duk_small_uint_fast_t i;
-+
-+			/* A -> unused (reserved for flags, for consistency with DUK_OP_CALL)
-+			 * B -> target register and start reg: constructor, arg1, ..., argN
-+			 *      (for DUK_OP_NEWI, 'b' is indirect)
-+			 * C -> num args (N)
-+			 */
-+
-+			/* Note: duk_new() will call the constuctor using duk_handle_call().
-+			 * A constructor call prevents a yield from inside the constructor,
-+			 * even if the constructor is an Ecmascript function.
-+			 */
-+
-+			/* XXX: unnecessary copying of values?  Just set 'top' to
-+			 * b + c, and let the return handling fix up the stack frame?
-+			 */
-+
-+			idx = (duk_uint_fast_t) DUK_DEC_B(ins);
-+			if (DUK_DEC_OP(ins) == DUK_OP_NEWI) {
-+				duk_tval *tv_ind = DUK__REGP(idx);
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
-+				idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
-+			}
-+
-+#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
-+			if (idx + c + 1 > (duk_uint_fast_t) duk_get_top(ctx)) {
-+				/* XXX: use duk_is_valid_index() instead? */
-+				/* XXX: improve check; check against nregs, not against top */
-+				DUK__INTERNAL_ERROR("NEW out of bounds");
-+			}
-+#endif
-+
-+			duk_require_stack(ctx, (duk_idx_t) c);
-+			duk_push_tval(ctx, DUK__REGP(idx));
-+			for (i = 0; i < c; i++) {
-+				duk_push_tval(ctx, DUK__REGP(idx + i + 1));
-+			}
-+			duk_new(ctx, (duk_idx_t) c);  /* [... constructor arg1 ... argN] -> [retval] */
-+			DUK_DDD(DUK_DDDPRINT("NEW -> %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
-+			duk_replace(ctx, (duk_idx_t) idx);
-+			break;
-+		}
-+
-+		case DUK_OP_REGEXP: {
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+
-+			/* A -> target register
-+			 * B -> bytecode (also contains flags)
-+			 * C -> escaped source
-+			 */
-+
-+			duk_push_tval(ctx, DUK__REGCONSTP(c));
-+			duk_push_tval(ctx, DUK__REGCONSTP(b));  /* -> [ ... escaped_source bytecode ] */
-+			duk_regexp_create_instance(thr);   /* -> [ ... regexp_instance ] */
-+			DUK_DDD(DUK_DDDPRINT("regexp instance: %!iT", (duk_tval *) duk_get_tval(ctx, -1)));
-+			duk_replace(ctx, (duk_idx_t) a);
-+#else
-+			/* The compiler should never emit DUK_OP_REGEXP if there is no
-+			 * regexp support.
-+			 */
-+			DUK__INTERNAL_ERROR("no regexp support");
-+#endif
-+
-+			break;
-+		}
-+
-+		case DUK_OP_CSREG:
-+		case DUK_OP_CSREGI: {
-+			/*
-+			 *  Assuming a register binds to a variable declared within this
-+			 *  function (a declarative binding), the 'this' for the call
-+			 *  setup is always 'undefined'.  E5 Section 10.2.1.1.6.
-+			 */
-+
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);  /* restricted to regs */
-+			duk_uint_fast_t idx;
-+
-+			/* A -> target register (A, A+1) for call setup
-+			 *      (for DUK_OP_CSREGI, 'a' is indirect)
-+			 * B -> register containing target function (not type checked here)
-+			 */
-+
-+			/* XXX: direct manipulation, or duk_replace_tval() */
-+
-+			/* Note: target registers a and a+1 may overlap with DUK__REGP(b).
-+			 * Careful here.
-+			 */
-+
-+			idx = (duk_uint_fast_t) DUK_DEC_A(ins);
-+			if (DUK_DEC_OP(ins) == DUK_OP_CSREGI) {
-+				duk_tval *tv_ind = DUK__REGP(idx);
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
-+				idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
-+			}
-+
-+#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
-+			if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
-+				/* XXX: use duk_is_valid_index() instead? */
-+				/* XXX: improve check; check against nregs, not against top */
-+				DUK__INTERNAL_ERROR("CSREG out of bounds");
-+			}
-+#endif
-+
-+			duk_push_tval(ctx, DUK__REGP(b));
-+			duk_replace(ctx, (duk_idx_t) idx);
-+			duk_push_undefined(ctx);
-+			duk_replace(ctx, (duk_idx_t) (idx + 1));
-+			break;
-+		}
-+
-+		case DUK_OP_GETVAR: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+			duk_tval *tv1;
-+			duk_hstring *name;
-+
-+			tv1 = DUK__CONSTP(bc);
-+			DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
-+			name = DUK_TVAL_GET_STRING(tv1);
-+			DUK_ASSERT(name != NULL);
-+			DUK_DDD(DUK_DDDPRINT("GETVAR: '%!O'", (duk_heaphdr *) name));
-+			(void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/);  /* -> [... val this] */
-+
-+			duk_pop(ctx);  /* 'this' binding is not needed here */
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		case DUK_OP_PUTVAR: {
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+			duk_tval *tv1;
-+			duk_hstring *name;
-+
-+			tv1 = DUK__CONSTP(bc);
-+			DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
-+			name = DUK_TVAL_GET_STRING(tv1);
-+			DUK_ASSERT(name != NULL);
-+
-+			/* XXX: putvar takes a duk_tval pointer, which is awkward and
-+			 * should be reworked.
-+			 */
-+
-+			tv1 = DUK__REGP(a);  /* val */
-+			duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
-+			break;
-+		}
-+
-+		case DUK_OP_DECLVAR: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_tval *tv1;
-+			duk_hstring *name;
-+			duk_small_uint_t prop_flags;
-+			duk_bool_t is_func_decl;
-+			duk_bool_t is_undef_value;
-+
-+			tv1 = DUK__REGCONSTP(b);
-+			DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
-+			name = DUK_TVAL_GET_STRING(tv1);
-+			DUK_ASSERT(name != NULL);
-+
-+			is_undef_value = ((a & DUK_BC_DECLVAR_FLAG_UNDEF_VALUE) != 0);
-+			is_func_decl = ((a & DUK_BC_DECLVAR_FLAG_FUNC_DECL) != 0);
-+
-+			/* XXX: declvar takes an duk_tval pointer, which is awkward and
-+			 * should be reworked.
-+			 */
-+
-+			/* Compiler is responsible for selecting property flags (configurability,
-+			 * writability, etc).
-+			 */
-+			prop_flags = a & DUK_PROPDESC_FLAGS_MASK;
-+
-+			if (is_undef_value) {
-+				duk_push_undefined(ctx);
-+			} else {
-+				duk_push_tval(ctx, DUK__REGCONSTP(c));
-+			}
-+			tv1 = duk_get_tval(ctx, -1);
-+
-+			if (duk_js_declvar_activation(thr, act, name, tv1, prop_flags, is_func_decl)) {
-+				/* already declared, must update binding value */
-+				tv1 = duk_get_tval(ctx, -1);
-+				duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
-+			}
-+
-+			duk_pop(ctx);
-+			break;
-+		}
-+
-+		case DUK_OP_DELVAR: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_tval *tv1;
-+			duk_hstring *name;
-+			duk_bool_t rc;
-+
-+			tv1 = DUK__REGCONSTP(b);
-+			DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
-+			name = DUK_TVAL_GET_STRING(tv1);
-+			DUK_ASSERT(name != NULL);
-+			DUK_DDD(DUK_DDDPRINT("DELVAR '%!O'", (duk_heaphdr *) name));
-+			rc = duk_js_delvar_activation(thr, act, name);
-+
-+			duk_push_boolean(ctx, rc);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		case DUK_OP_CSVAR:
-+		case DUK_OP_CSVARI: {
-+			/* 'this' value:
-+			 * E5 Section 6.b.i
-+			 *
-+			 * The only (standard) case where the 'this' binding is non-null is when
-+			 *   (1) the variable is found in an object environment record, and
-+			 *   (2) that object environment record is a 'with' block.
-+			 *
-+			 */
-+
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_uint_fast_t idx;
-+			duk_tval *tv1;
-+			duk_hstring *name;
-+
-+			tv1 = DUK__REGCONSTP(b);
-+			DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
-+			name = DUK_TVAL_GET_STRING(tv1);
-+			DUK_ASSERT(name != NULL);
-+			(void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/);  /* -> [... val this] */
-+
-+			/* Note: target registers a and a+1 may overlap with DUK__REGCONSTP(b)
-+			 * and DUK__REGCONSTP(c).  Careful here.
-+			 */
-+
-+			idx = (duk_uint_fast_t) DUK_DEC_A(ins);
-+			if (DUK_DEC_OP(ins) == DUK_OP_CSVARI) {
-+				duk_tval *tv_ind = DUK__REGP(idx);
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
-+				idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
-+			}
-+
-+#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
-+			if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
-+				/* XXX: use duk_is_valid_index() instead? */
-+				/* XXX: improve check; check against nregs, not against top */
-+				DUK__INTERNAL_ERROR("CSVAR out of bounds");
-+			}
-+#endif
-+
-+			duk_replace(ctx, (duk_idx_t) (idx + 1));  /* 'this' binding */
-+			duk_replace(ctx, (duk_idx_t) idx);        /* variable value (function, we hope, not checked here) */
-+			break;
-+		}
-+
-+		case DUK_OP_CLOSURE: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+			duk_hobject *fun_temp;
-+
-+			/* A -> target reg
-+			 * BC -> inner function index
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("CLOSURE to target register %ld, fnum %ld (count %ld)",
-+			                     (long) a, (long) bc, (long) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, fun)));
-+
-+			DUK_ASSERT_DISABLE(bc >= 0); /* unsigned */
-+			DUK_ASSERT((duk_uint_t) bc < (duk_uint_t) DUK_HCOMPILEDFUNCTION_GET_FUNCS_COUNT(thr->heap, fun));
-+			fun_temp = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, fun)[bc];
-+			DUK_ASSERT(fun_temp != NULL);
-+			DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(fun_temp));
-+
-+			DUK_DDD(DUK_DDDPRINT("CLOSURE: function template is: %p -> %!O",
-+			                     (void *) fun_temp, (duk_heaphdr *) fun_temp));
-+
-+			if (act->lex_env == NULL) {
-+				DUK_ASSERT(act->var_env == NULL);
-+				duk_js_init_activation_environment_records_delayed(thr, act);
-+			}
-+			DUK_ASSERT(act->lex_env != NULL);
-+			DUK_ASSERT(act->var_env != NULL);
-+
-+			/* functions always have a NEWENV flag, i.e. they get a
-+			 * new variable declaration environment, so only lex_env
-+			 * matters here.
-+			 */
-+			duk_js_push_closure(thr,
-+			                    (duk_hcompiledfunction *) fun_temp,
-+			                    act->var_env,
-+			                    act->lex_env);
-+			duk_replace(ctx, (duk_idx_t) a);
-+
-+			break;
-+		}
-+
-+		case DUK_OP_GETPROP: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_tval *tv_obj;
-+			duk_tval *tv_key;
-+			duk_bool_t rc;
-+
-+			/* A -> target reg
-+			 * B -> object reg/const (may be const e.g. in "'foo'[1]")
-+			 * C -> key reg/const
-+			 */
-+
-+			tv_obj = DUK__REGCONSTP(b);
-+			tv_key = DUK__REGCONSTP(c);
-+			DUK_DDD(DUK_DDDPRINT("GETPROP: a=%ld obj=%!T, key=%!T",
-+			                     (long) a,
-+			                     (duk_tval *) DUK__REGCONSTP(b),
-+			                     (duk_tval *) DUK__REGCONSTP(c)));
-+			rc = duk_hobject_getprop(thr, tv_obj, tv_key);  /* -> [val] */
-+			DUK_UNREF(rc);  /* ignore */
-+			DUK_DDD(DUK_DDDPRINT("GETPROP --> %!T",
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			tv_obj = NULL;  /* invalidated */
-+			tv_key = NULL;  /* invalidated */
-+
-+			duk_replace(ctx, (duk_idx_t) a);    /* val */
-+			break;
-+		}
-+
-+		case DUK_OP_PUTPROP: {
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_tval *tv_obj;
-+			duk_tval *tv_key;
-+			duk_tval *tv_val;
-+			duk_bool_t rc;
-+
-+			/* A -> object reg
-+			 * B -> key reg/const
-+			 * C -> value reg/const
-+			 *
-+			 * Note: intentional difference to register arrangement
-+			 * of e.g. GETPROP; 'A' must contain a register-only value.
-+			 */
-+
-+			tv_obj = DUK__REGP(a);
-+			tv_key = DUK__REGCONSTP(b);
-+			tv_val = DUK__REGCONSTP(c);
-+			DUK_DDD(DUK_DDDPRINT("PUTPROP: obj=%!T, key=%!T, val=%!T",
-+			                     (duk_tval *) DUK__REGP(a),
-+			                     (duk_tval *) DUK__REGCONSTP(b),
-+			                     (duk_tval *) DUK__REGCONSTP(c)));
-+			rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, DUK__STRICT());
-+			DUK_UNREF(rc);  /* ignore */
-+			DUK_DDD(DUK_DDDPRINT("PUTPROP --> obj=%!T, key=%!T, val=%!T",
-+			                     (duk_tval *) DUK__REGP(a),
-+			                     (duk_tval *) DUK__REGCONSTP(b),
-+			                     (duk_tval *) DUK__REGCONSTP(c)));
-+			tv_obj = NULL;  /* invalidated */
-+			tv_key = NULL;  /* invalidated */
-+			tv_val = NULL;  /* invalidated */
-+
-+			break;
-+		}
-+
-+		case DUK_OP_DELPROP: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_tval *tv_obj;
-+			duk_tval *tv_key;
-+			duk_bool_t rc;
-+
-+			/* A -> result reg
-+			 * B -> object reg
-+			 * C -> key reg/const
-+			 */
-+
-+			tv_obj = DUK__REGP(b);
-+			tv_key = DUK__REGCONSTP(c);
-+			rc = duk_hobject_delprop(thr, tv_obj, tv_key, DUK__STRICT());
-+			tv_obj = NULL;  /* invalidated */
-+			tv_key = NULL;  /* invalidated */
-+
-+			duk_push_boolean(ctx, rc);
-+			duk_replace(ctx, (duk_idx_t) a);    /* result */
-+			break;
-+		}
-+
-+		case DUK_OP_CSPROP:
-+		case DUK_OP_CSPROPI: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_uint_fast_t idx;
-+			duk_tval *tv_obj;
-+			duk_tval *tv_key;
-+			duk_bool_t rc;
-+
-+			/* E5 Section 11.2.3, step 6.a.i */
-+			/* E5 Section 10.4.3 */
-+
-+			/* XXX: allow object to be a const, e.g. in 'foo'.toString()?
-+			 * On the other hand, DUK_REGCONSTP() is slower and generates
-+			 * more code.
-+			 */
-+
-+			tv_obj = DUK__REGP(b);
-+			tv_key = DUK__REGCONSTP(c);
-+			rc = duk_hobject_getprop(thr, tv_obj, tv_key);  /* -> [val] */
-+			DUK_UNREF(rc);  /* unused */
-+			tv_obj = NULL;  /* invalidated */
-+			tv_key = NULL;  /* invalidated */
-+
-+			/* Note: target registers a and a+1 may overlap with DUK__REGP(b)
-+			 * and DUK__REGCONSTP(c).  Careful here.
-+			 */
-+
-+			idx = (duk_uint_fast_t) DUK_DEC_A(ins);
-+			if (DUK_DEC_OP(ins) == DUK_OP_CSPROPI) {
-+				duk_tval *tv_ind = DUK__REGP(idx);
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
-+				idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
-+			}
-+
-+#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
-+			if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
-+				/* XXX: use duk_is_valid_index() instead? */
-+				/* XXX: improve check; check against nregs, not against top */
-+				DUK__INTERNAL_ERROR("CSPROP out of bounds");
-+			}
-+#endif
-+
-+			duk_push_tval(ctx, DUK__REGP(b));         /* [ ... val obj ] */
-+			duk_replace(ctx, (duk_idx_t) (idx + 1));  /* 'this' binding */
-+			duk_replace(ctx, (duk_idx_t) idx);        /* val */
-+			break;
-+		}
-+
-+		case DUK_OP_ADD:
-+		case DUK_OP_SUB:
-+		case DUK_OP_MUL:
-+		case DUK_OP_DIV:
-+		case DUK_OP_MOD: {
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_small_uint_fast_t op = DUK_DEC_OP(ins);
-+
-+			if (op == DUK_OP_ADD) {
-+				/*
-+				 *  Handling DUK_OP_ADD this way is more compact (experimentally)
-+				 *  than a separate case with separate argument decoding.
-+				 */
-+				duk__vm_arith_add(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a);
-+			} else {
-+				duk__vm_arith_binary_op(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a, op);
-+			}
-+			break;
-+		}
-+
-+		case DUK_OP_BAND:
-+		case DUK_OP_BOR:
-+		case DUK_OP_BXOR:
-+		case DUK_OP_BASL:
-+		case DUK_OP_BLSR:
-+		case DUK_OP_BASR: {
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_small_uint_fast_t op = DUK_DEC_OP(ins);
-+
-+			duk__vm_bitwise_binary_op(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c), a, op);
-+			break;
-+		}
-+
-+		case DUK_OP_EQ:
-+		case DUK_OP_NEQ: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_bool_t tmp;
-+
-+			/* E5 Sections 11.9.1, 11.9.3 */
-+			tmp = duk_js_equals(thr, DUK__REGCONSTP(b), DUK__REGCONSTP(c));
-+			if (DUK_DEC_OP(ins) == DUK_OP_NEQ) {
-+				tmp = !tmp;
-+			}
-+			duk_push_boolean(ctx, tmp);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		case DUK_OP_SEQ:
-+		case DUK_OP_SNEQ: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_bool_t tmp;
-+
-+			/* E5 Sections 11.9.1, 11.9.3 */
-+			tmp = duk_js_strict_equals(DUK__REGCONSTP(b), DUK__REGCONSTP(c));
-+			if (DUK_DEC_OP(ins) == DUK_OP_SNEQ) {
-+				tmp = !tmp;
-+			}
-+			duk_push_boolean(ctx, tmp);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		/* Note: combining comparison ops must be done carefully because
-+		 * of uncomparable values (NaN): it's not necessarily true that
-+		 * (x >= y) === !(x < y).  Also, evaluation order matters, and
-+		 * although it would only seem to affect the compiler this is
-+		 * actually not the case, because there are also run-time coercions
-+		 * of the arguments (with potential side effects).
-+		 *
-+		 * XXX: can be combined; check code size.
-+		 */
-+
-+		case DUK_OP_GT: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_bool_t tmp;
-+
-+			/* x > y  -->  y < x */
-+			tmp = duk_js_compare_helper(thr,
-+			                            DUK__REGCONSTP(c),  /* y */
-+			                            DUK__REGCONSTP(b),  /* x */
-+			                            0);                 /* flags */
-+
-+			duk_push_boolean(ctx, tmp);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		case DUK_OP_GE: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_bool_t tmp;
-+
-+			/* x >= y  -->  not (x < y) */
-+			tmp = duk_js_compare_helper(thr,
-+			                            DUK__REGCONSTP(b),  /* x */
-+			                            DUK__REGCONSTP(c),  /* y */
-+			                            DUK_COMPARE_FLAG_EVAL_LEFT_FIRST |
-+			                            DUK_COMPARE_FLAG_NEGATE);  /* flags */
-+
-+			duk_push_boolean(ctx, tmp);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		case DUK_OP_LT: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_bool_t tmp;
-+
-+			/* x < y */
-+			tmp = duk_js_compare_helper(thr,
-+			                            DUK__REGCONSTP(b),  /* x */
-+			                            DUK__REGCONSTP(c),  /* y */
-+			                            DUK_COMPARE_FLAG_EVAL_LEFT_FIRST);  /* flags */
-+
-+			duk_push_boolean(ctx, tmp);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		case DUK_OP_LE: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_bool_t tmp;
-+
-+			/* x <= y  -->  not (x > y)  -->  not (y < x) */
-+			tmp = duk_js_compare_helper(thr,
-+			                            DUK__REGCONSTP(c),  /* y */
-+			                            DUK__REGCONSTP(b),  /* x */
-+			                            DUK_COMPARE_FLAG_NEGATE);  /* flags */
-+
-+			duk_push_boolean(ctx, tmp);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		case DUK_OP_IF: {
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_bool_t tmp;
-+
-+			tmp = duk_js_toboolean(DUK__REGCONSTP(b));
-+			if (tmp == (duk_bool_t) a) {
-+				/* if boolean matches A, skip next inst */
-+				act->pc++;
-+			} else {
-+				;
-+			}
-+			break;
-+		}
-+
-+		case DUK_OP_JUMP: {
-+			duk_int_fast_t abc = DUK_DEC_ABC(ins);
-+
-+			act->pc += abc - DUK_BC_JUMP_BIAS;
-+			break;
-+		}
-+
-+		case DUK_OP_RETURN: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			/* duk_small_uint_fast_t c = DUK_DEC_C(ins); */
-+			duk_tval *tv_val;
-+
-+			/* A -> flags
-+			 * B -> return value reg/const
-+			 * C -> currently unused
-+			 */
-+
-+			/* A fast return avoids full longjmp handling for a set of
-+			 * scenarios which hopefully represents the common cases.
-+			 * The compiler is responsible for emitting fast returns
-+			 * only when they are safe.  Currently this means that there
-+			 * is nothing on the catch stack (not even label catchers).
-+			 * The speed advantage of fast returns (avoiding longjmp) is
-+			 * not very high, around 10-15%.
-+			 */
-+#if 0  /* XXX: Disabled for 1.0 release */
-+			if (a & DUK_BC_RETURN_FLAG_FAST) {
-+				DUK_DDD(DUK_DDDPRINT("FASTRETURN attempt a=%ld b=%ld", (long) a, (long) b));
-+
-+				if (duk__handle_fast_return(thr,
-+				                            (a & DUK_BC_RETURN_FLAG_HAVE_RETVAL) ? DUK__REGCONSTP(b) : NULL,
-+				                            entry_thread,
-+				                            entry_callstack_top)) {
-+					DUK_DDD(DUK_DDDPRINT("FASTRETURN success a=%ld b=%ld", (long) a, (long) b));
-+					goto restart_execution;
-+				}
-+			}
-+#endif
-+
-+			/* No fast return, slow path. */
-+			DUK_DDD(DUK_DDDPRINT("SLOWRETURN a=%ld b=%ld", (long) a, (long) b));
-+
-+			if (a & DUK_BC_RETURN_FLAG_HAVE_RETVAL) {
-+				tv_val = DUK__REGCONSTP(b);
-+#if defined(DUK_OPT_FASTINT)
-+				/* Explicit check for fastint downgrade.  Do
-+				 * it also for consts for now, which is odd
-+				 * but harmless.
-+				 */
-+				/* XXX: restrict to reg values only? */
-+
-+				DUK_TVAL_CHKFAST_INPLACE(tv_val);
-+#endif
-+				duk_push_tval(ctx, tv_val);
-+			} else {
-+				duk_push_undefined(ctx);
-+			}
-+
-+			duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_RETURN);
-+
-+			DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* in bytecode executor, should always be set */
-+			duk_err_longjmp(thr);
-+			DUK_UNREACHABLE();
-+			break;
-+		}
-+
-+		case DUK_OP_CALL:
-+		case DUK_OP_CALLI: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_uint_fast_t idx;
-+			duk_small_uint_t call_flags;
-+			duk_small_uint_t flag_tailcall;
-+			duk_small_uint_t flag_evalcall;
-+			duk_tval *tv_func;
-+			duk_hobject *obj_func;
-+			duk_bool_t setup_rc;
-+			duk_idx_t num_stack_args;
-+
-+			/* A -> flags
-+			 * B -> base register for call (base -> func, base+1 -> this, base+2 -> arg1 ... base+2+N-1 -> argN)
-+			 *      (for DUK_OP_CALLI, 'b' is indirect)
-+			 * C -> nargs
-+			 */
-+
-+			/* these are not necessarily 0 or 1 (may be other non-zero), that's ok */
-+			flag_tailcall = (a & DUK_BC_CALL_FLAG_TAILCALL);
-+			flag_evalcall = (a & DUK_BC_CALL_FLAG_EVALCALL);
-+
-+			idx = (duk_uint_fast_t) DUK_DEC_B(ins);
-+			if (DUK_DEC_OP(ins) == DUK_OP_CALLI) {
-+				duk_tval *tv_ind = DUK__REGP(idx);
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
-+				idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
-+			}
-+
-+#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
-+			if (!duk_is_valid_index(ctx, (duk_idx_t) idx)) {
-+				/* XXX: improve check; check against nregs, not against top */
-+				DUK__INTERNAL_ERROR("CALL out of bounds");
-+			}
-+#endif
-+
-+			/*
-+			 *  To determine whether to use an optimized Ecmascript-to-Ecmascript
-+			 *  call, we need to know whether the final, non-bound function is an
-+			 *  Ecmascript function.
-+			 *
-+			 *  This is now implemented so that we start to do an ecma-to-ecma call
-+			 *  setup which will resolve the bound chain as the first thing.  If the
-+			 *  final function is not eligible, the return value indicates that the
-+			 *  ecma-to-ecma call is not possible.  The setup will overwrite the call
-+			 *  target at DUK__REGP(idx) with the final, non-bound function (which
-+			 *  may be a lightfunc), and fudge arguments if necessary.
-+			 *
-+			 *  XXX: If an ecma-to-ecma call is not possible, this initial call
-+			 *  setup will do bound function chain resolution but won't do the
-+			 *  "effective this binding" resolution which is quite confusing.
-+			 *  Perhaps add a helper for doing bound function and effective this
-+			 *  binding resolution - and call that explicitly?  Ecma-to-ecma call
-+			 *  setup and normal function handling can then assume this prestep has
-+			 *  been done by the caller.
-+			 */
-+
-+			duk_set_top(ctx, (duk_idx_t) (idx + c + 2));   /* [ ... func this arg1 ... argN ] */
-+
-+			call_flags = 0;
-+			if (flag_tailcall) {
-+				/* We request a tailcall, but in some corner cases
-+				 * call handling can decide that a tailcall is
-+				 * actually not possible.
-+				 * See: test-bug-tailcall-preventyield-assert.c.
-+				 */
-+				call_flags |= DUK_CALL_FLAG_IS_TAILCALL;
-+			}
-+
-+			/* Compared to duk_handle_call():
-+			 *   - protected call: never
-+			 *   - ignore recursion limit: never
-+			 */
-+			num_stack_args = c;
-+			setup_rc = duk_handle_ecma_call_setup(thr,
-+			                                      num_stack_args,
-+			                                      call_flags);
-+
-+			if (setup_rc) {
-+				/* Ecma-to-ecma call possible, may or may not be a tailcall.
-+				 * Avoid C recursion by being clever.
-+				 */
-+				DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call setup possible, restart execution"));
-+				goto restart_execution;
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("ecma-to-ecma call not possible, target is native (may be lightfunc)"));
-+
-+			/* Recompute argument count: bound function handling may have shifted. */
-+			num_stack_args = duk_get_top(ctx) - (idx + 2);
-+			DUK_DDD(DUK_DDDPRINT("recomputed arg count: %ld\n", (long) num_stack_args));
-+
-+			tv_func = DUK__REGP(idx);  /* Relookup if relocated */
-+			if (DUK_TVAL_IS_LIGHTFUNC(tv_func)) {
-+				call_flags = 0;  /* not protected, respect reclimit, not constructor */
-+
-+				/* There is no eval() special handling here: eval() is never
-+				 * automatically converted to a lightfunc.
-+				 */
-+				DUK_ASSERT(DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv_func) != duk_bi_global_object_eval);
-+
-+				duk_handle_call(thr,
-+				                num_stack_args,
-+				                call_flags);
-+
-+				/* duk_js_call.c is required to restore the stack reserve
-+				 * so we only need to reset the top.
-+				 */
-+				duk_set_top(ctx, (duk_idx_t) fun->nregs);
-+
-+				/* No need to reinit setjmp() catchpoint, as call handling
-+				 * will store and restore our state.
-+				 */
-+			} else {
-+				/* Call setup checks callability. */
-+				DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv_func));
-+				obj_func = DUK_TVAL_GET_OBJECT(tv_func);
-+				DUK_ASSERT(obj_func != NULL);
-+				DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(obj_func));
-+
-+				/*
-+				 *  Other cases, use C recursion.
-+				 *
-+				 *  If a tailcall was requested we ignore it and execute a normal call.
-+				 *  Since Duktape 0.11.0 the compiler emits a RETURN opcode even after
-+				 *  a tailcall to avoid test-bug-tailcall-thread-yield-resume.js.
-+				 *
-+				 *  Direct eval call: (1) call target (before following bound function
-+				 *  chain) is the built-in eval() function, and (2) call was made with
-+				 *  the identifier 'eval'.
-+				 */
-+
-+				call_flags = 0;  /* not protected, respect reclimit, not constructor */
-+
-+				if (DUK_HOBJECT_IS_NATIVEFUNCTION(obj_func) &&
-+				    ((duk_hnativefunction *) obj_func)->func == duk_bi_global_object_eval) {
-+					if (flag_evalcall) {
-+						DUK_DDD(DUK_DDDPRINT("call target is eval, call identifier was 'eval' -> direct eval"));
-+						call_flags |= DUK_CALL_FLAG_DIRECT_EVAL;
-+					} else {
-+						DUK_DDD(DUK_DDDPRINT("call target is eval, call identifier was not 'eval' -> indirect eval"));
-+					}
-+				}
-+
-+				duk_handle_call(thr,
-+				                num_stack_args,
-+				                call_flags);
-+
-+				/* duk_js_call.c is required to restore the stack reserve
-+				 * so we only need to reset the top.
-+				 */
-+				duk_set_top(ctx, (duk_idx_t) fun->nregs);
-+
-+				/* No need to reinit setjmp() catchpoint, as call handling
-+				 * will store and restore our state.
-+				 */
-+			}
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+			/* When debugger is enabled, we need to recheck the activation
-+			 * status after returning.
-+			 */
-+			goto restart_execution;
-+#endif
-+			break;
-+		}
-+
-+		case DUK_OP_TRYCATCH: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_catcher *cat;
-+			duk_tval *tv1;
-+			duk_small_uint_fast_t a;
-+			duk_small_uint_fast_t b;
-+			duk_small_uint_fast_t c;
-+
-+			/* A -> flags
-+			 * B -> reg_catch; base register for 2 regs
-+			 * C -> semantics depend on flags: var_name or with_target
-+			 *
-+			 *      If DUK_BC_TRYCATCH_FLAG_CATCH_BINDING set:
-+			 *          C is constant index for catch binding variable name.
-+			 *          Automatic declarative environment is established for
-+			 *          the duration of the 'catch' clause.
-+			 *
-+			 *      If DUK_BC_TRYCATCH_FLAG_WITH_BINDING set:
-+			 *          C is reg/const index for with 'target value', which
-+			 *          is coerced to an object and then used as a binding
-+			 *          object for an environment record.  The binding is
-+			 *          initialized here, for the 'try' clause.
-+			 *
-+			 * Note that a TRYCATCH generated for a 'with' statement has no
-+			 * catch or finally parts.
-+			 */
-+
-+			/* XXX: side effect handling is quite awkward here */
-+
-+			DUK_DDD(DUK_DDDPRINT("TRYCATCH: reg_catch=%ld, var_name/with_target=%ld, have_catch=%ld, "
-+			                     "have_finally=%ld, catch_binding=%ld, with_binding=%ld (flags=0x%02lx)",
-+			                     (long) DUK_DEC_B(ins),
-+			                     (long) DUK_DEC_C(ins),
-+			                     (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH ? 1 : 0),
-+			                     (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY ? 1 : 0),
-+			                     (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING ? 1 : 0),
-+			                     (long) (DUK_DEC_A(ins) & DUK_BC_TRYCATCH_FLAG_WITH_BINDING ? 1 : 0),
-+			                     (unsigned long) DUK_DEC_A(ins)));
-+
-+			a = DUK_DEC_A(ins);
-+			b = DUK_DEC_B(ins);
-+			c = DUK_DEC_C(ins);
-+
-+			DUK_ASSERT(thr->callstack_top >= 1);
-+
-+			/* 'with' target must be created first, in case we run out of memory */
-+			/* XXX: refactor out? */
-+
-+			if (a & DUK_BC_TRYCATCH_FLAG_WITH_BINDING) {
-+				DUK_DDD(DUK_DDDPRINT("need to initialize a with binding object"));
-+
-+				if (act->lex_env == NULL) {
-+					DUK_ASSERT(act->var_env == NULL);
-+					DUK_DDD(DUK_DDDPRINT("delayed environment initialization"));
-+
-+					/* must relookup act in case of side effects */
-+					duk_js_init_activation_environment_records_delayed(thr, act);
-+					act = thr->callstack + thr->callstack_top - 1;
-+				}
-+				DUK_ASSERT(act->lex_env != NULL);
-+				DUK_ASSERT(act->var_env != NULL);
-+
-+				(void) duk_push_object_helper(ctx,
-+				                              DUK_HOBJECT_FLAG_EXTENSIBLE |
-+				                              DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_OBJENV),
-+				                              -1);  /* no prototype, updated below */
-+
-+				duk_push_tval(ctx, DUK__REGCONSTP(c));
-+				duk_to_object(ctx, -1);
-+				duk_dup(ctx, -1);
-+
-+				/* [ ... env target ] */
-+				/* [ ... env target target ] */
-+
-+				duk_xdef_prop_stridx(thr, -3, DUK_STRIDX_INT_TARGET, DUK_PROPDESC_FLAGS_NONE);
-+				duk_xdef_prop_stridx(thr, -2, DUK_STRIDX_INT_THIS, DUK_PROPDESC_FLAGS_NONE);  /* always provideThis=true */
-+
-+				/* [ ... env ] */
-+
-+				DUK_DDD(DUK_DDDPRINT("environment for with binding: %!iT",
-+				                     (duk_tval *) duk_get_tval(ctx, -1)));
-+			}
-+
-+			/* allocate catcher and populate it (should be atomic) */
-+
-+			duk_hthread_catchstack_grow(thr);
-+			cat = thr->catchstack + thr->catchstack_top;
-+			DUK_ASSERT(thr->catchstack_top + 1 <= thr->catchstack_size);
-+			thr->catchstack_top++;
-+
-+			cat->flags = DUK_CAT_TYPE_TCF;
-+			cat->h_varname = NULL;
-+
-+			if (a & DUK_BC_TRYCATCH_FLAG_HAVE_CATCH) {
-+				cat->flags |= DUK_CAT_FLAG_CATCH_ENABLED;
-+			}
-+			if (a & DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY) {
-+				cat->flags |= DUK_CAT_FLAG_FINALLY_ENABLED;
-+			}
-+			if (a & DUK_BC_TRYCATCH_FLAG_CATCH_BINDING) {
-+				DUK_DDD(DUK_DDDPRINT("catch binding flag set to catcher"));
-+				cat->flags |= DUK_CAT_FLAG_CATCH_BINDING_ENABLED;
-+				tv1 = DUK__CONSTP(c);
-+				DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
-+				cat->h_varname = DUK_TVAL_GET_STRING(tv1);
-+			} else if (a & DUK_BC_TRYCATCH_FLAG_WITH_BINDING) {
-+				/* env created above to stack top */
-+				duk_hobject *new_env;
-+
-+				DUK_DDD(DUK_DDDPRINT("lexenv active flag set to catcher"));
-+				cat->flags |= DUK_CAT_FLAG_LEXENV_ACTIVE;
-+
-+				DUK_DDD(DUK_DDDPRINT("activating object env: %!iT",
-+				                     (duk_tval *) duk_get_tval(ctx, -1)));
-+				DUK_ASSERT(act->lex_env != NULL);
-+				new_env = duk_get_hobject(ctx, -1);
-+				DUK_ASSERT(new_env != NULL);
-+
-+				act = thr->callstack + thr->callstack_top - 1;  /* relookup (side effects) */
-+				DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, new_env, act->lex_env);
-+
-+				act = thr->callstack + thr->callstack_top - 1;  /* relookup (side effects) */
-+				act->lex_env = new_env;
-+				DUK_HOBJECT_INCREF(thr, new_env);
-+				duk_pop(ctx);
-+			} else {
-+				;
-+			}
-+
-+			cat = thr->catchstack + thr->catchstack_top - 1;  /* relookup (side effects) */
-+			cat->callstack_index = thr->callstack_top - 1;
-+			cat->pc_base = act->pc;  /* pre-incremented, points to first jump slot */
-+			cat->idx_base = (duk_size_t) (thr->valstack_bottom - thr->valstack) + b;
-+
-+			DUK_DDD(DUK_DDDPRINT("TRYCATCH catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, "
-+			                     "idx_base=%ld, h_varname=%!O",
-+			                     (unsigned long) cat->flags, (long) cat->callstack_index,
-+			                     (long) cat->pc_base, (long) cat->idx_base, (duk_heaphdr *) cat->h_varname));
-+
-+			act->pc += 2;  /* skip jump slots */
-+			break;
-+		}
-+
-+		/* Pre/post inc/dec for register variables, important for loops. */
-+		case DUK_OP_PREINCR:
-+		case DUK_OP_PREDECR:
-+		case DUK_OP_POSTINCR:
-+		case DUK_OP_POSTDECR: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+			duk_tval *tv1, *tv2;
-+			duk_tval tv_tmp;
-+			duk_double_t x, y, z;
-+
-+			/* Two lowest bits of opcode are used to distinguish
-+			 * variants.  Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
-+			 */
-+			DUK_ASSERT((DUK_OP_PREINCR & 0x03) == 0x00);
-+			DUK_ASSERT((DUK_OP_PREDECR & 0x03) == 0x01);
-+			DUK_ASSERT((DUK_OP_POSTINCR & 0x03) == 0x02);
-+			DUK_ASSERT((DUK_OP_POSTDECR & 0x03) == 0x03);
-+
-+			tv1 = DUK__REGP(bc);
-+#if defined(DUK_USE_FASTINT)
-+			if (DUK_TVAL_IS_FASTINT(tv1)) {
-+				duk_int64_t x_fi, y_fi, z_fi;
-+				x_fi = DUK_TVAL_GET_FASTINT(tv1);
-+				if (ins & DUK_ENC_OP(0x01)) {
-+					if (x_fi == DUK_FASTINT_MIN) {
-+						goto skip_fastint;
-+					}
-+					y_fi = x_fi - 1;
-+				} else {
-+					if (x_fi == DUK_FASTINT_MAX) {
-+						goto skip_fastint;
-+					}
-+					y_fi = x_fi + 1;
-+				}
-+
-+				DUK_TVAL_SET_FASTINT(tv1, y_fi);  /* no need for refcount update */
-+
-+				tv2 = DUK__REGP(a);
-+				DUK_TVAL_SET_TVAL(&tv_tmp, tv2);
-+				z_fi = (ins & DUK_ENC_OP(0x02)) ? x_fi : y_fi;
-+				DUK_TVAL_SET_FASTINT(tv2, z_fi);    /* no need for incref */
-+				DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+				break;
-+			}
-+		 skip_fastint:
-+#endif
-+			if (DUK_TVAL_IS_NUMBER(tv1)) {
-+				/* Fast path for the case where the register
-+				 * is a number (e.g. loop counter).
-+				 */
-+
-+				x = DUK_TVAL_GET_NUMBER(tv1);
-+				if (ins & DUK_ENC_OP(0x01)) {
-+					y = x - 1.0;
-+				} else {
-+					y = x + 1.0;
-+				}
-+
-+				DUK_TVAL_SET_NUMBER(tv1, y);  /* no need for refcount update */
-+			} else {
-+				x = duk_to_number(ctx, bc);
-+
-+				if (ins & DUK_ENC_OP(0x01)) {
-+					y = x - 1.0;
-+				} else {
-+					y = x + 1.0;
-+				}
-+
-+				duk_push_number(ctx, y);
-+				duk_replace(ctx, bc);
-+			}
-+
-+			tv2 = DUK__REGP(a);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv2);
-+			z = (ins & DUK_ENC_OP(0x02)) ? x : y;
-+			DUK_TVAL_SET_NUMBER(tv2, z);    /* no need for incref */
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+			break;
-+		}
-+
-+		/* Preinc/predec for var-by-name, slow path. */
-+		case DUK_OP_PREINCV:
-+		case DUK_OP_PREDECV:
-+		case DUK_OP_POSTINCV:
-+		case DUK_OP_POSTDECV: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+			duk_double_t x, y;
-+			duk_tval *tv1;
-+			duk_hstring *name;
-+
-+			/* Two lowest bits of opcode are used to distinguish
-+			 * variants.  Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
-+			 */
-+			DUK_ASSERT((DUK_OP_PREINCV & 0x03) == 0x00);
-+			DUK_ASSERT((DUK_OP_PREDECV & 0x03) == 0x01);
-+			DUK_ASSERT((DUK_OP_POSTINCV & 0x03) == 0x02);
-+			DUK_ASSERT((DUK_OP_POSTDECV & 0x03) == 0x03);
-+
-+			tv1 = DUK__CONSTP(bc);
-+			DUK_ASSERT(DUK_TVAL_IS_STRING(tv1));
-+			name = DUK_TVAL_GET_STRING(tv1);
-+			DUK_ASSERT(name != NULL);
-+			(void) duk_js_getvar_activation(thr, act, name, 1 /*throw*/);  /* -> [... val this] */
-+
-+			/* XXX: fastint fast path would be very useful here */
-+
-+			x = duk_to_number(ctx, -2);
-+			duk_pop_2(ctx);
-+			if (ins & DUK_ENC_OP(0x01)) {
-+				y = x - 1.0;
-+			} else {
-+				y = x + 1.0;
-+			}
-+
-+			duk_push_number(ctx, y);
-+			tv1 = duk_get_tval(ctx, -1);
-+			DUK_ASSERT(tv1 != NULL);
-+			duk_js_putvar_activation(thr, act, name, tv1, DUK__STRICT());
-+			duk_pop(ctx);
-+
-+			duk_push_number(ctx, (ins & DUK_ENC_OP(0x02)) ? x : y);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		/* Preinc/predec for object properties. */
-+		case DUK_OP_PREINCP:
-+		case DUK_OP_PREDECP:
-+		case DUK_OP_POSTINCP:
-+		case DUK_OP_POSTDECP: {
-+			duk_context *ctx = (duk_context *) thr;
-+			duk_small_uint_fast_t a = DUK_DEC_A(ins);
-+			duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+			duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+			duk_tval *tv_obj;
-+			duk_tval *tv_key;
-+			duk_tval *tv_val;
-+			duk_bool_t rc;
-+			duk_double_t x, y;
-+
-+			/* A -> target reg
-+			 * B -> object reg/const (may be const e.g. in "'foo'[1]")
-+			 * C -> key reg/const
-+			 */
-+
-+			/* Two lowest bits of opcode are used to distinguish
-+			 * variants.  Bit 0 = inc(0)/dec(1), bit 1 = pre(0)/post(1).
-+			 */
-+			DUK_ASSERT((DUK_OP_PREINCP & 0x03) == 0x00);
-+			DUK_ASSERT((DUK_OP_PREDECP & 0x03) == 0x01);
-+			DUK_ASSERT((DUK_OP_POSTINCP & 0x03) == 0x02);
-+			DUK_ASSERT((DUK_OP_POSTDECP & 0x03) == 0x03);
-+
-+			tv_obj = DUK__REGCONSTP(b);
-+			tv_key = DUK__REGCONSTP(c);
-+			rc = duk_hobject_getprop(thr, tv_obj, tv_key);  /* -> [val] */
-+			DUK_UNREF(rc);  /* ignore */
-+			tv_obj = NULL;  /* invalidated */
-+			tv_key = NULL;  /* invalidated */
-+
-+			x = duk_to_number(ctx, -1);
-+			duk_pop(ctx);
-+			if (ins & DUK_ENC_OP(0x01)) {
-+				y = x - 1.0;
-+			} else {
-+				y = x + 1.0;
-+			}
-+
-+			duk_push_number(ctx, y);
-+			tv_val = duk_get_tval(ctx, -1);
-+			DUK_ASSERT(tv_val != NULL);
-+			tv_obj = DUK__REGCONSTP(b);
-+			tv_key = DUK__REGCONSTP(c);
-+			rc = duk_hobject_putprop(thr, tv_obj, tv_key, tv_val, DUK__STRICT());
-+			DUK_UNREF(rc);  /* ignore */
-+			tv_obj = NULL;  /* invalidated */
-+			tv_key = NULL;  /* invalidated */
-+			duk_pop(ctx);
-+
-+			duk_push_number(ctx, (ins & DUK_ENC_OP(0x02)) ? x : y);
-+			duk_replace(ctx, (duk_idx_t) a);
-+			break;
-+		}
-+
-+		case DUK_OP_EXTRA: {
-+			/* XXX: shared decoding of 'b' and 'c'? */
-+
-+			duk_small_uint_fast_t extraop = DUK_DEC_A(ins);
-+			switch ((int) extraop) {
-+			/* XXX: switch cast? */
-+
-+			case DUK_EXTRAOP_NOP: {
-+				/* nop */
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_INVALID: {
-+				DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "INVALID opcode (%ld)", (long) DUK_DEC_BC(ins));
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_LDTHIS: {
-+				/* Note: 'this' may be bound to any value, not just an object */
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+				duk_tval tv_tmp;
-+				duk_tval *tv1, *tv2;
-+
-+				tv1 = DUK__REGP(bc);
-+				tv2 = thr->valstack_bottom - 1;  /* 'this binding' is just under bottom */
-+				DUK_ASSERT(tv2 >= thr->valstack);
-+
-+				DUK_DDD(DUK_DDDPRINT("LDTHIS: %!T to r%ld", (duk_tval *) tv2, (long) bc));
-+
-+				DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+				DUK_TVAL_SET_TVAL(tv1, tv2);
-+				DUK_TVAL_INCREF(thr, tv1);
-+				DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_LDUNDEF: {
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+				duk_tval tv_tmp;
-+				duk_tval *tv1;
-+
-+				tv1 = DUK__REGP(bc);
-+				DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+				DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1);
-+				DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_LDNULL: {
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+				duk_tval tv_tmp;
-+				duk_tval *tv1;
-+
-+				tv1 = DUK__REGP(bc);
-+				DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+				DUK_TVAL_SET_NULL(tv1);
-+				DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_LDTRUE:
-+			case DUK_EXTRAOP_LDFALSE: {
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+				duk_tval tv_tmp;
-+				duk_tval *tv1;
-+				duk_small_uint_fast_t bval = (extraop == DUK_EXTRAOP_LDTRUE ? 1 : 0);
-+
-+				tv1 = DUK__REGP(bc);
-+				DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+				DUK_TVAL_SET_BOOLEAN(tv1, bval);
-+				DUK_TVAL_DECREF(thr, &tv_tmp);  /* side effects */
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_NEWOBJ: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+
-+				duk_push_object(ctx);
-+				duk_replace(ctx, (duk_idx_t) b);
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_NEWARR: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+
-+				duk_push_array(ctx);
-+				duk_replace(ctx, (duk_idx_t) b);
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_SETALEN: {
-+				duk_small_uint_fast_t b;
-+				duk_small_uint_fast_t c;
-+				duk_tval *tv1;
-+				duk_hobject *h;
-+				duk_uint32_t len;
-+
-+				b = DUK_DEC_B(ins); tv1 = DUK__REGP(b);
-+				DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv1));
-+				h = DUK_TVAL_GET_OBJECT(tv1);
-+
-+				c = DUK_DEC_C(ins); tv1 = DUK__REGP(c);
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
-+				len = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv1);
-+
-+				duk_hobject_set_length(thr, h, len);
-+
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_TYPEOF: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+				duk_push_hstring(ctx, duk_js_typeof(thr, DUK__REGP(bc)));
-+				duk_replace(ctx, (duk_idx_t) bc);
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_TYPEOFID: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+				duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+				duk_hstring *name;
-+				duk_tval *tv;
-+
-+				/* B -> target register
-+				 * C -> constant index of identifier name
-+				 */
-+
-+				tv = DUK__REGCONSTP(c);  /* XXX: this could be a DUK__CONSTP instead */
-+				DUK_ASSERT(DUK_TVAL_IS_STRING(tv));
-+				name = DUK_TVAL_GET_STRING(tv);
-+				if (duk_js_getvar_activation(thr, act, name, 0 /*throw*/)) {
-+					/* -> [... val this] */
-+					tv = duk_get_tval(ctx, -2);
-+					duk_push_hstring(ctx, duk_js_typeof(thr, tv));
-+					duk_replace(ctx, (duk_idx_t) b);
-+					duk_pop_2(ctx);
-+				} else {
-+					/* unresolvable, no stack changes */
-+					duk_push_hstring_stridx(ctx, DUK_STRIDX_LC_UNDEFINED);
-+					duk_replace(ctx, (duk_idx_t) b);
-+				}
-+
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_INITENUM: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+				duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+
-+				/*
-+				 *  Enumeration semantics come from for-in statement, E5 Section 12.6.4.
-+				 *  If called with 'null' or 'undefined', this opcode returns 'null' as
-+				 *  the enumerator, which is special cased in NEXTENUM.  This simplifies
-+				 *  the compiler part
-+				 */
-+
-+				/* B -> register for writing enumerator object
-+				 * C -> value to be enumerated (register)
-+				 */
-+
-+				if (duk_is_null_or_undefined(ctx, (duk_idx_t) c)) {
-+					duk_push_null(ctx);
-+					duk_replace(ctx, (duk_idx_t) b);
-+				} else {
-+					duk_dup(ctx, (duk_idx_t) c);
-+					duk_to_object(ctx, -1);
-+					duk_hobject_enumerator_create(ctx, 0 /*enum_flags*/);  /* [ ... val ] --> [ ... enum ] */
-+					duk_replace(ctx, (duk_idx_t) b);
-+				}
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_NEXTENUM: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+				duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+
-+				/*
-+				 *  NEXTENUM checks whether the enumerator still has unenumerated
-+				 *  keys.  If so, the next key is loaded to the target register
-+				 *  and the next instruction is skipped.  Otherwise the next instruction
-+				 *  will be executed, jumping out of the enumeration loop.
-+				 */
-+
-+				/* B -> target register for next key
-+				 * C -> enum register
-+				 */
-+
-+				DUK_DDD(DUK_DDDPRINT("NEXTENUM: b->%!T, c->%!T",
-+				                     (duk_tval *) duk_get_tval(ctx, (duk_idx_t) b),
-+				                     (duk_tval *) duk_get_tval(ctx, (duk_idx_t) c)));
-+
-+				if (duk_is_object(ctx, (duk_idx_t) c)) {
-+					/* XXX: assert 'c' is an enumerator */
-+					duk_dup(ctx, (duk_idx_t) c);
-+					if (duk_hobject_enumerator_next(ctx, 0 /*get_value*/)) {
-+						/* [ ... enum ] -> [ ... next_key ] */
-+						DUK_DDD(DUK_DDDPRINT("enum active, next key is %!T, skip jump slot ",
-+						                     (duk_tval *) duk_get_tval(ctx, -1)));
-+						act->pc++;;
-+					} else {
-+						/* [ ... enum ] -> [ ... ] */
-+						DUK_DDD(DUK_DDDPRINT("enum finished, execute jump slot"));
-+						duk_push_undefined(ctx);
-+					}
-+					duk_replace(ctx, (duk_idx_t) b);
-+				} else {
-+					/* 'null' enumerator case -> behave as with an empty enumerator */
-+					DUK_ASSERT(duk_is_null(ctx, (duk_idx_t) c));
-+					DUK_DDD(DUK_DDDPRINT("enum is null, execute jump slot"));
-+				}
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_INITSET:
-+			case DUK_EXTRAOP_INITSETI:
-+			case DUK_EXTRAOP_INITGET:
-+			case DUK_EXTRAOP_INITGETI: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_bool_t is_set = (extraop == DUK_EXTRAOP_INITSET || extraop == DUK_EXTRAOP_INITSETI);
-+				duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+				duk_uint_fast_t idx;
-+
-+				/* B -> object register
-+				 * C -> C+0 contains key, C+1 closure (value)
-+				 */
-+
-+				/*
-+				 *  INITSET/INITGET are only used to initialize object literal keys.
-+				 *  The compiler ensures that there cannot be a previous data property
-+				 *  of the same name.  It also ensures that setter and getter can only
-+				 *  be initialized once (or not at all).
-+				 */
-+
-+				idx = (duk_uint_fast_t) DUK_DEC_C(ins);
-+				if (extraop == DUK_EXTRAOP_INITSETI || extraop == DUK_EXTRAOP_INITGETI) {
-+					duk_tval *tv_ind = DUK__REGP(idx);
-+					DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_ind));
-+					idx = (duk_uint_fast_t) DUK_TVAL_GET_NUMBER(tv_ind);
-+				}
-+
-+#if defined(DUK_USE_EXEC_INDIRECT_BOUND_CHECK)
-+				if (idx + 2 > (duk_uint_fast_t) duk_get_top(ctx)) {
-+					/* XXX: use duk_is_valid_index() instead? */
-+					/* XXX: improve check; check against nregs, not against top */
-+					DUK__INTERNAL_ERROR("INITSET/INITGET out of bounds");
-+				}
-+#endif
-+
-+				/* XXX: this is now a very unoptimal implementation -- this can be
-+				 * made very simple by direct manipulation of the object internals,
-+				 * given the guarantees above.
-+				 */
-+
-+				duk_push_hobject_bidx(ctx, DUK_BIDX_OBJECT_CONSTRUCTOR);
-+				duk_get_prop_stridx(ctx, -1, DUK_STRIDX_DEFINE_PROPERTY);
-+				duk_push_undefined(ctx);
-+				duk_dup(ctx, (duk_idx_t) b);
-+				duk_dup(ctx, (duk_idx_t) (idx + 0));
-+				duk_push_object(ctx);  /* -> [ Object defineProperty undefined obj key desc ] */
-+
-+				duk_push_true(ctx);
-+				duk_put_prop_stridx(ctx, -2, DUK_STRIDX_ENUMERABLE);
-+				duk_push_true(ctx);
-+				duk_put_prop_stridx(ctx, -2, DUK_STRIDX_CONFIGURABLE);
-+				duk_dup(ctx, (duk_idx_t) (idx + 1));
-+				duk_put_prop_stridx(ctx, -2, (is_set ? DUK_STRIDX_SET : DUK_STRIDX_GET));
-+
-+				DUK_DDD(DUK_DDDPRINT("INITGET/INITSET: obj=%!T, key=%!T, desc=%!T",
-+				                     (duk_tval *) duk_get_tval(ctx, -3),
-+				                     (duk_tval *) duk_get_tval(ctx, -2),
-+				                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+				duk_call_method(ctx, 3);  /* -> [ Object res ] */
-+				duk_pop_2(ctx);
-+
-+				DUK_DDD(DUK_DDDPRINT("INITGET/INITSET AFTER: obj=%!T",
-+				                     (duk_tval *) duk_get_tval(ctx, (duk_idx_t) b)));
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_ENDTRY: {
-+				duk_catcher *cat;
-+				duk_tval tv_tmp;
-+				duk_tval *tv1;
-+
-+				DUK_ASSERT(thr->catchstack_top >= 1);
-+				DUK_ASSERT(thr->callstack_top >= 1);
-+				DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
-+
-+				cat = thr->catchstack + thr->catchstack_top - 1;
-+
-+				DUK_DDD(DUK_DDDPRINT("ENDTRY: clearing catch active flag (regardless of whether it was set or not)"));
-+				DUK_CAT_CLEAR_CATCH_ENABLED(cat);
-+
-+				if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
-+					DUK_DDD(DUK_DDDPRINT("ENDTRY: finally part is active, jump through 2nd jump slot with 'normal continuation'"));
-+
-+					tv1 = thr->valstack + cat->idx_base;
-+					DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
-+					DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+					DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1);
-+					DUK_TVAL_DECREF(thr, &tv_tmp);     /* side effects */
-+					tv1 = NULL;
-+
-+					tv1 = thr->valstack + cat->idx_base + 1;
-+					DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
-+					DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+					DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) DUK_LJ_TYPE_NORMAL);  /* XXX: set int */
-+					DUK_TVAL_DECREF(thr, &tv_tmp);     /* side effects */
-+					tv1 = NULL;
-+
-+					DUK_CAT_CLEAR_FINALLY_ENABLED(cat);
-+				} else {
-+					DUK_DDD(DUK_DDDPRINT("ENDTRY: no finally part, dismantle catcher, jump through 2nd jump slot (to end of statement)"));
-+					duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
-+					/* no need to unwind callstack */
-+				}
-+
-+				act->pc = cat->pc_base + 1;
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_ENDCATCH: {
-+				duk_catcher *cat;
-+				duk_tval tv_tmp;
-+				duk_tval *tv1;
-+
-+				DUK_ASSERT(thr->catchstack_top >= 1);
-+				DUK_ASSERT(thr->callstack_top >= 1);
-+				DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
-+
-+				cat = thr->catchstack + thr->catchstack_top - 1;
-+				DUK_ASSERT(!DUK_CAT_HAS_CATCH_ENABLED(cat));  /* cleared before entering catch part */
-+
-+				if (DUK_CAT_HAS_LEXENV_ACTIVE(cat)) {
-+					duk_hobject *prev_env;
-+
-+					/* 'with' binding has no catch clause, so can't be here unless a normal try-catch */
-+					DUK_ASSERT(DUK_CAT_HAS_CATCH_BINDING_ENABLED(cat));
-+					DUK_ASSERT(act->lex_env != NULL);
-+
-+					DUK_DDD(DUK_DDDPRINT("ENDCATCH: popping catcher part lexical environment"));
-+
-+					prev_env = act->lex_env;
-+					DUK_ASSERT(prev_env != NULL);
-+					act->lex_env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, prev_env);
-+					DUK_CAT_CLEAR_LEXENV_ACTIVE(cat);
-+					DUK_HOBJECT_DECREF(thr, prev_env);  /* side effects */
-+				}
-+
-+				if (DUK_CAT_HAS_FINALLY_ENABLED(cat)) {
-+					DUK_DDD(DUK_DDDPRINT("ENDCATCH: finally part is active, jump through 2nd jump slot with 'normal continuation'"));
-+
-+					tv1 = thr->valstack + cat->idx_base;
-+					DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
-+					DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+					DUK_TVAL_SET_UNDEFINED_ACTUAL(tv1);
-+					DUK_TVAL_DECREF(thr, &tv_tmp);     /* side effects */
-+					tv1 = NULL;
-+
-+					tv1 = thr->valstack + cat->idx_base + 1;
-+					DUK_ASSERT(tv1 >= thr->valstack && tv1 < thr->valstack_top);
-+					DUK_TVAL_SET_TVAL(&tv_tmp, tv1);
-+					DUK_TVAL_SET_NUMBER(tv1, (duk_double_t) DUK_LJ_TYPE_NORMAL);  /* XXX: set int */
-+					DUK_TVAL_DECREF(thr, &tv_tmp);     /* side effects */
-+					tv1 = NULL;
-+
-+					DUK_CAT_CLEAR_FINALLY_ENABLED(cat);
-+				} else {
-+					DUK_DDD(DUK_DDDPRINT("ENDCATCH: no finally part, dismantle catcher, jump through 2nd jump slot (to end of statement)"));
-+					duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
-+					/* no need to unwind callstack */
-+				}
-+
-+				act->pc = cat->pc_base + 1;
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_ENDFIN: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_catcher *cat;
-+				duk_tval *tv1;
-+				duk_small_uint_fast_t cont_type;
-+
-+				DUK_ASSERT(thr->catchstack_top >= 1);
-+				DUK_ASSERT(thr->callstack_top >= 1);
-+				DUK_ASSERT(thr->catchstack[thr->catchstack_top - 1].callstack_index == thr->callstack_top - 1);
-+
-+				cat = thr->catchstack + thr->catchstack_top - 1;
-+
-+				/* CATCH flag may be enabled or disabled here; it may be enabled if
-+				 * the statement has a catch block but the try block does not throw
-+				 * an error.
-+				 */
-+				DUK_ASSERT(!DUK_CAT_HAS_FINALLY_ENABLED(cat));  /* cleared before entering finally */
-+				/* XXX: assert idx_base */
-+
-+				DUK_DDD(DUK_DDDPRINT("ENDFIN: completion value=%!T, type=%!T",
-+				                     (duk_tval *) (thr->valstack + cat->idx_base + 0),
-+				                     (duk_tval *) (thr->valstack + cat->idx_base + 1)));
-+
-+				tv1 = thr->valstack + cat->idx_base + 1;  /* type */
-+				DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv1));
-+				cont_type = (duk_small_uint_fast_t) DUK_TVAL_GET_NUMBER(tv1);
-+
-+				if (cont_type == DUK_LJ_TYPE_NORMAL) {
-+					DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with 'normal' (non-abrupt) completion -> "
-+					                     "dismantle catcher, resume execution after ENDFIN"));
-+					duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
-+					/* no need to unwind callstack */
-+				} else {
-+					DUK_DDD(DUK_DDDPRINT("ENDFIN: finally part finishing with abrupt completion, lj_type=%ld -> "
-+					                     "dismantle catcher, re-throw error",
-+					                     (long) cont_type));
-+
-+					duk_push_tval(ctx, thr->valstack + cat->idx_base);
-+
-+					/* XXX: assert lj type valid */
-+					duk_err_setup_heap_ljstate(thr, (duk_small_int_t) cont_type);
-+
-+					DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* always in executor */
-+					duk_err_longjmp(thr);
-+					DUK_UNREACHABLE();
-+				}
-+
-+				/* continue execution after ENDFIN */
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_THROW: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+
-+				/* Note: errors are augmented when they are created, not
-+				 * when they are thrown.  So, don't augment here, it would
-+				 * break re-throwing for instance.
-+				 */
-+
-+				duk_dup(ctx, (duk_idx_t) bc);
-+				DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (before throw augment)",
-+				                     (duk_tval *) duk_get_tval(ctx, -1)));
-+#if defined(DUK_USE_AUGMENT_ERROR_THROW)
-+				duk_err_augment_error_throw(thr);
-+				DUK_DDD(DUK_DDDPRINT("THROW ERROR (BYTECODE): %!dT (after throw augment)",
-+				                     (duk_tval *) duk_get_tval(ctx, -1)));
-+#endif
-+
-+				duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_THROW);
-+
-+				DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* always in executor */
-+				duk_err_longjmp(thr);
-+
-+				DUK_UNREACHABLE();
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_INVLHS: {
-+				DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, "invalid lvalue");
-+
-+				DUK_UNREACHABLE();
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_UNM:
-+			case DUK_EXTRAOP_UNP: {
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+				duk__vm_arith_unary_op(thr, DUK__REGP(bc), bc, extraop);
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_DEBUGGER: {
-+				/* Opcode only emitted by compiler when debugger
-+				 * support is enabled.  Ignore it silently without
-+				 * debugger support, in case it has been loaded
-+				 * from precompiled bytecode.
-+				 */
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+				DUK_D(DUK_DPRINT("DEBUGGER statement encountered, halt execution"));
-+				if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) {
-+					DUK_HEAP_SET_PAUSED(thr->heap);
-+					goto restart_execution;
-+				}
-+#else
-+				DUK_D(DUK_DPRINT("DEBUGGER statement ignored, no debugger support"));
-+#endif
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_BREAK: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+
-+				/* always the "slow break" variant (longjmp'ing); a "fast break" is
-+				 * simply an DUK_OP_JUMP.
-+				 */
-+
-+				DUK_DDD(DUK_DDDPRINT("BREAK: %ld", (long) bc));
-+
-+				duk_push_uint(ctx, (duk_uint_t) bc);
-+				duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_BREAK);
-+
-+				DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* always in executor */
-+				duk_err_longjmp(thr);
-+
-+				DUK_UNREACHABLE();
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_CONTINUE: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+
-+				/* always the "slow continue" variant (longjmp'ing); a "fast continue" is
-+				 * simply an DUK_OP_JUMP.
-+				 */
-+
-+				DUK_DDD(DUK_DDDPRINT("CONTINUE: %ld", (long) bc));
-+
-+				duk_push_uint(ctx, (duk_uint_t) bc);
-+				duk_err_setup_heap_ljstate(thr, DUK_LJ_TYPE_CONTINUE);
-+
-+				DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* always in executor */
-+				duk_err_longjmp(thr);
-+
-+				DUK_UNREACHABLE();
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_BNOT: {
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+
-+				duk__vm_bitwise_not(thr, DUK__REGP(bc), bc);
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_LNOT: {
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+				duk_tval *tv1;
-+
-+				tv1 = DUK__REGP(bc);
-+				duk__vm_logical_not(thr, tv1, tv1);
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_INSTOF: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+				duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+				duk_bool_t tmp;
-+
-+				tmp = duk_js_instanceof(thr, DUK__REGP(b), DUK__REGCONSTP(c));
-+				duk_push_boolean(ctx, tmp);
-+				duk_replace(ctx, (duk_idx_t) b);
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_IN: {
-+				duk_context *ctx = (duk_context *) thr;
-+				duk_small_uint_fast_t b = DUK_DEC_B(ins);
-+				duk_small_uint_fast_t c = DUK_DEC_C(ins);
-+				duk_bool_t tmp;
-+
-+				tmp = duk_js_in(thr, DUK__REGP(b), DUK__REGCONSTP(c));
-+				duk_push_boolean(ctx, tmp);
-+				duk_replace(ctx, (duk_idx_t) b);
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_LABEL: {
-+				duk_catcher *cat;
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+
-+				/* allocate catcher and populate it (should be atomic) */
-+
-+				duk_hthread_catchstack_grow(thr);
-+				cat = thr->catchstack + thr->catchstack_top;
-+				thr->catchstack_top++;
-+
-+				cat->flags = DUK_CAT_TYPE_LABEL | (bc << DUK_CAT_LABEL_SHIFT);
-+				cat->callstack_index = thr->callstack_top - 1;
-+				cat->pc_base = act->pc;  /* pre-incremented, points to first jump slot */
-+				cat->idx_base = 0;  /* unused for label */
-+				cat->h_varname = NULL;
-+
-+				DUK_DDD(DUK_DDDPRINT("LABEL catcher: flags=0x%08lx, callstack_index=%ld, pc_base=%ld, "
-+				                     "idx_base=%ld, h_varname=%!O, label_id=%ld",
-+				                     (long) cat->flags, (long) cat->callstack_index, (long) cat->pc_base,
-+				                     (long) cat->idx_base, (duk_heaphdr *) cat->h_varname, (long) DUK_CAT_GET_LABEL(cat)));
-+
-+				act->pc += 2;  /* skip jump slots */
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_ENDLABEL: {
-+				duk_catcher *cat;
-+#if defined(DUK_USE_DDDPRINT) || defined(DUK_USE_ASSERTIONS)
-+				duk_uint_fast_t bc = DUK_DEC_BC(ins);
-+#endif
-+#if defined(DUK_USE_DDDPRINT)
-+				DUK_DDD(DUK_DDDPRINT("ENDLABEL %ld", (long) bc));
-+#endif
-+
-+				DUK_ASSERT(thr->catchstack_top >= 1);
-+
-+				cat = thr->catchstack + thr->catchstack_top - 1;
-+				DUK_UNREF(cat);
-+				DUK_ASSERT(DUK_CAT_GET_TYPE(cat) == DUK_CAT_TYPE_LABEL);
-+				DUK_ASSERT((duk_uint_fast_t) DUK_CAT_GET_LABEL(cat) == bc);
-+
-+				duk_hthread_catchstack_unwind(thr, thr->catchstack_top - 1);
-+				/* no need to unwind callstack */
-+				break;
-+			}
-+
-+#ifdef DUK_USE_DEBUG
-+			case DUK_EXTRAOP_DUMPREG: {
-+				DUK_D(DUK_DPRINT("DUMPREG: %ld -> %!T",
-+				                 (long) DUK_DEC_BC(ins),
-+				                 (duk_tval *) duk_get_tval((duk_context *) thr, (duk_idx_t) DUK_DEC_BC(ins))));
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_DUMPREGS: {
-+				duk_idx_t i, i_top;
-+				i_top = duk_get_top((duk_context *) thr);
-+				DUK_D(DUK_DPRINT("DUMPREGS: %ld regs", (long) i_top));
-+				for (i = 0; i < i_top; i++) {
-+					DUK_D(DUK_DPRINT("  r%ld -> %!dT",
-+					                 (long) i,
-+					                 (duk_tval *) duk_get_tval((duk_context *) thr, i)));
-+				}
-+				break;
-+			}
-+
-+			case DUK_EXTRAOP_LOGMARK: {
-+				DUK_D(DUK_DPRINT("LOGMARK: mark %ld at pc %ld", (long) DUK_DEC_BC(ins), (long) (act->pc - 1)));  /* -1, autoinc */
-+				break;
-+			}
-+#endif  /* DUK_USE_DEBUG */
-+
-+			default: {
-+				DUK__INTERNAL_ERROR("invalid extra opcode");
-+			}
-+
-+			}  /* end switch */
-+
-+			break;
-+		}
-+
-+		default: {
-+			/* this should never be possible, because the switch-case is
-+			 * comprehensive
-+			 */
-+			DUK__INTERNAL_ERROR("invalid opcode");
-+			break;
-+		}
-+
-+		}  /* end switch */
-+	}
-+	DUK_UNREACHABLE();
-+
-+#ifndef DUK_USE_VERBOSE_EXECUTOR_ERRORS
-+ internal_error:
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "internal error in bytecode executor");
-+#endif
-+}
-+
-+#undef DUK__INTERNAL_ERROR
-+#line 1 "duk_js_ops.c"
-+/*
-+ *  Ecmascript specification algorithm and conversion helpers.
-+ *
-+ *  These helpers encapsulate the primitive Ecmascript operation
-+ *  semantics, and are used by the bytecode executor and the API
-+ *  (among other places).  Note that some primitives are only
-+ *  implemented as part of the API and have no "internal" helper.
-+ *  (This is the case when an internal helper would not really be
-+ *  useful; e.g. the operation is rare, uses value stack heavily,
-+ *  etc.)
-+ *
-+ *  The operation arguments depend on what is required to implement
-+ *  the operation:
-+ *
-+ *    - If an operation is simple and stateless, and has no side
-+ *      effects, it won't take an duk_hthread argument and its
-+ *      arguments may be duk_tval pointers (which are safe as long
-+ *      as no side effects take place).
-+ *
-+ *    - If complex coercions are required (e.g. a "ToNumber" coercion)
-+ *      or errors may be thrown, the operation takes an duk_hthread
-+ *      argument.  This also implies that the operation may have
-+ *      arbitrary side effects, invalidating any duk_tval pointers.
-+ *
-+ *    - For operations with potential side effects, arguments can be
-+ *      taken in several ways:
-+ *
-+ *      a) as duk_tval pointers, which makes sense if the "common case"
-+ *         can be resolved without side effects (e.g. coercion); the
-+ *         arguments are pushed to the valstack for coercion if
-+ *         necessary
-+ *
-+ *      b) as duk_tval values
-+ *
-+ *      c) implicitly on value stack top
-+ *
-+ *      d) as indices to the value stack
-+ *
-+ *  Future work:
-+ *
-+ *     - Argument styles may not be the most sensible in every case now.
-+ *
-+ *     - In-place coercions might be useful for several operations, if
-+ *       in-place coercion is OK for the bytecode executor and the API.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  [[DefaultValue]]  (E5 Section 8.12.8)
-+ *
-+ *  ==> implemented in the API.
-+ */
-+
-+/*
-+ *  ToPrimitive()  (E5 Section 9.1)
-+ *
-+ *  ==> implemented in the API.
-+ */
-+
-+/*
-+ *  ToBoolean()  (E5 Section 9.2)
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_js_toboolean(duk_tval *tv) {
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED:
-+	case DUK_TAG_NULL:
-+		return 0;
-+	case DUK_TAG_BOOLEAN:
-+		return DUK_TVAL_GET_BOOLEAN(tv);
-+	case DUK_TAG_STRING: {
-+		duk_hstring *h = DUK_TVAL_GET_STRING(tv);
-+		DUK_ASSERT(h != NULL);
-+		return (DUK_HSTRING_GET_BYTELEN(h) > 0 ? 1 : 0);
-+	}
-+	case DUK_TAG_OBJECT: {
-+		return 1;
-+	}
-+	case DUK_TAG_BUFFER: {
-+		/* mimic semantics for strings */
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
-+		DUK_ASSERT(h != NULL);
-+		return (DUK_HBUFFER_GET_SIZE(h) > 0 ? 1 : 0);
-+	}
-+	case DUK_TAG_POINTER: {
-+		void *p = DUK_TVAL_GET_POINTER(tv);
-+		return (p != NULL ? 1 : 0);
-+	}
-+	case DUK_TAG_LIGHTFUNC: {
-+		return 1;
-+	}
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+		if (DUK_TVAL_GET_FASTINT(tv) != 0) {
-+			return 1;
-+		} else {
-+			return 0;
-+		}
-+#endif
-+	default: {
-+		/* number */
-+		duk_double_t d;
-+		int c;
-+		DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv));
-+		d = DUK_TVAL_GET_DOUBLE(tv);
-+		c = DUK_FPCLASSIFY((double) d);
-+		if (c == DUK_FP_ZERO || c == DUK_FP_NAN) {
-+			return 0;
-+		} else {
-+			return 1;
-+		}
-+	}
-+	}
-+	DUK_UNREACHABLE();
-+}
-+
-+/*
-+ *  ToNumber()  (E5 Section 9.3)
-+ *
-+ *  Value to convert must be on stack top, and is popped before exit.
-+ *
-+ *  See: http://www.cs.indiana.edu/~burger/FP-Printing-PLDI96.pdf
-+ *       http://www.cs.indiana.edu/~burger/fp/index.html
-+ *
-+ *  Notes on the conversion:
-+ *
-+ *    - There are specific requirements on the accuracy of the conversion
-+ *      through a "Mathematical Value" (MV), so this conversion is not
-+ *      trivial.
-+ *
-+ *    - Quick rejects (e.g. based on first char) are difficult because
-+ *      the grammar allows leading and trailing white space.
-+ *
-+ *    - Quick reject based on string length is difficult even after
-+ *      accounting for white space; there may be arbitrarily many
-+ *      decimal digits.
-+ *
-+ *    - Standard grammar allows decimal values ("123"), hex values
-+ *      ("0x123") and infinities
-+ *
-+ *    - Unlike source code literals, ToNumber() coerces empty strings
-+ *      and strings with only whitespace to zero (not NaN).
-+ */
-+
-+/* E5 Section 9.3.1 */
-+DUK_LOCAL duk_double_t duk__tonumber_string_raw(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_small_uint_t s2n_flags;
-+	duk_double_t d;
-+
-+	/* Quite lenient, e.g. allow empty as zero, but don't allow trailing
-+	 * garbage.
-+	 */
-+	s2n_flags = DUK_S2N_FLAG_TRIM_WHITE |
-+	            DUK_S2N_FLAG_ALLOW_EXP |
-+	            DUK_S2N_FLAG_ALLOW_PLUS |
-+	            DUK_S2N_FLAG_ALLOW_MINUS |
-+	            DUK_S2N_FLAG_ALLOW_INF |
-+	            DUK_S2N_FLAG_ALLOW_FRAC |
-+	            DUK_S2N_FLAG_ALLOW_NAKED_FRAC |
-+	            DUK_S2N_FLAG_ALLOW_EMPTY_FRAC |
-+	            DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO |
-+	            DUK_S2N_FLAG_ALLOW_LEADING_ZERO |
-+	            DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT;
-+
-+	duk_numconv_parse(ctx, 10 /*radix*/, s2n_flags);
-+	d = duk_get_number(ctx, -1);
-+	duk_pop(ctx);
-+
-+	return d;
-+}
-+
-+DUK_INTERNAL duk_double_t duk_js_tonumber(duk_hthread *thr, duk_tval *tv) {
-+	duk_context *ctx = (duk_hthread *) thr;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(tv != NULL);
-+
-+	switch (DUK_TVAL_GET_TAG(tv)) {
-+	case DUK_TAG_UNDEFINED: {
-+		/* return a specific NaN (although not strictly necessary) */
-+		duk_double_union du;
-+		DUK_DBLUNION_SET_NAN(&du);
-+		DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&du));
-+		return du.d;
-+	}
-+	case DUK_TAG_NULL: {
-+		/* +0.0 */
-+		return 0.0;
-+	}
-+	case DUK_TAG_BOOLEAN: {
-+		if (DUK_TVAL_IS_BOOLEAN_TRUE(tv)) {
-+			return 1.0;
-+		}
-+		return 0.0;
-+	}
-+	case DUK_TAG_STRING: {
-+		duk_hstring *h = DUK_TVAL_GET_STRING(tv);
-+		duk_push_hstring(ctx, h);
-+		return duk__tonumber_string_raw(thr);
-+	}
-+	case DUK_TAG_OBJECT: {
-+		/* Note: ToPrimitive(object,hint) == [[DefaultValue]](object,hint),
-+		 * so use [[DefaultValue]] directly.
-+		 */
-+		duk_double_t d;
-+		duk_push_tval(ctx, tv);
-+		duk_to_defaultvalue(ctx, -1, DUK_HINT_NUMBER);  /* 'tv' becomes invalid */
-+
-+		/* recursive call for a primitive value (guaranteed not to cause second
-+		 * recursion).
-+		 */
-+		d = duk_js_tonumber(thr, duk_require_tval(ctx, -1));
-+
-+		duk_pop(ctx);
-+		return d;
-+	}
-+	case DUK_TAG_BUFFER: {
-+		/* Coerce like a string.  This makes sense because addition also treats
-+		 * buffers like strings.
-+		 */
-+		duk_hbuffer *h = DUK_TVAL_GET_BUFFER(tv);
-+		duk_push_hbuffer(ctx, h);
-+		duk_to_string(ctx, -1);  /* XXX: expensive, but numconv now expects to see a string */
-+		return duk__tonumber_string_raw(thr);
-+	}
-+	case DUK_TAG_POINTER: {
-+		/* Coerce like boolean */
-+		void *p = DUK_TVAL_GET_POINTER(tv);
-+		return (p != NULL ? 1.0 : 0.0);
-+	}
-+	case DUK_TAG_LIGHTFUNC: {
-+		/* +(function(){}) -> NaN */
-+		return DUK_DOUBLE_NAN;
-+	}
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+		return (duk_double_t) DUK_TVAL_GET_FASTINT(tv);
-+#endif
-+	default: {
-+		/* number */
-+		DUK_ASSERT(DUK_TVAL_IS_DOUBLE(tv));
-+		return DUK_TVAL_GET_DOUBLE(tv);
-+	}
-+	}
-+
-+	DUK_UNREACHABLE();
-+}
-+
-+/*
-+ *  ToInteger()  (E5 Section 9.4)
-+ */
-+
-+/* exposed, used by e.g. duk_bi_date.c */
-+DUK_INTERNAL duk_double_t duk_js_tointeger_number(duk_double_t x) {
-+	duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
-+
-+	if (c == DUK_FP_NAN) {
-+		return 0.0;
-+	} else if (c == DUK_FP_ZERO || c == DUK_FP_INFINITE) {
-+		/* XXX: FP_ZERO check can be removed, the else clause handles it
-+		 * correctly (preserving sign).
-+		 */
-+		return x;
-+	} else {
-+		duk_small_int_t s = (duk_small_int_t) DUK_SIGNBIT(x);
-+		x = DUK_FLOOR(DUK_FABS(x));  /* truncate towards zero */
-+		if (s) {
-+			x = -x;
-+		}
-+		return x;
-+	}
-+}
-+
-+DUK_INTERNAL duk_double_t duk_js_tointeger(duk_hthread *thr, duk_tval *tv) {
-+	/* XXX: fastint */
-+	duk_double_t d = duk_js_tonumber(thr, tv);  /* invalidates tv */
-+	return duk_js_tointeger_number(d);
-+}
-+
-+/*
-+ *  ToInt32(), ToUint32(), ToUint16()  (E5 Sections 9.5, 9.6, 9.7)
-+ */
-+
-+/* combined algorithm matching E5 Sections 9.5 and 9.6 */
-+DUK_LOCAL duk_double_t duk__toint32_touint32_helper(duk_double_t x, duk_bool_t is_toint32) {
-+	duk_small_int_t c = (duk_small_int_t) DUK_FPCLASSIFY(x);
-+	duk_small_int_t s;
-+
-+	if (c == DUK_FP_NAN || c == DUK_FP_ZERO || c == DUK_FP_INFINITE) {
-+		return 0.0;
-+	}
-+
-+
-+	/* x = sign(x) * floor(abs(x)), i.e. truncate towards zero, keep sign */
-+	s = (duk_small_int_t) DUK_SIGNBIT(x);
-+	x = DUK_FLOOR(DUK_FABS(x));
-+	if (s) {
-+		x = -x;
-+	}
-+
-+	/* NOTE: fmod(x) result sign is same as sign of x, which
-+	 * differs from what Javascript wants (see Section 9.6).
-+	 */
-+
-+	x = DUK_FMOD(x, DUK_DOUBLE_2TO32);    /* -> x in ]-2**32, 2**32[ */
-+
-+	if (x < 0.0) {
-+		x += DUK_DOUBLE_2TO32;
-+	}
-+	/* -> x in [0, 2**32[ */
-+
-+	if (is_toint32) {
-+		if (x >= DUK_DOUBLE_2TO31) {
-+			/* x in [2**31, 2**32[ */
-+
-+			x -= DUK_DOUBLE_2TO32;  /* -> x in [-2**31,2**31[ */
-+		}
-+	}
-+
-+	return x;
-+}
-+
-+DUK_INTERNAL duk_int32_t duk_js_toint32(duk_hthread *thr, duk_tval *tv) {
-+	duk_double_t d;
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv)) {
-+		return DUK_TVAL_GET_FASTINT_I32(tv);
-+	}
-+#endif
-+
-+	d = duk_js_tonumber(thr, tv);  /* invalidates tv */
-+	d = duk__toint32_touint32_helper(d, 1);
-+	DUK_ASSERT(DUK_FPCLASSIFY(d) == DUK_FP_ZERO || DUK_FPCLASSIFY(d) == DUK_FP_NORMAL);
-+	DUK_ASSERT(d >= -2147483648.0 && d <= 2147483647.0);  /* [-0x80000000,0x7fffffff] */
-+	DUK_ASSERT(d == ((duk_double_t) ((duk_int32_t) d)));  /* whole, won't clip */
-+	return (duk_int32_t) d;
-+}
-+
-+
-+DUK_INTERNAL duk_uint32_t duk_js_touint32(duk_hthread *thr, duk_tval *tv) {
-+	duk_double_t d;
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv)) {
-+		return DUK_TVAL_GET_FASTINT_U32(tv);
-+	}
-+#endif
-+
-+	d = duk_js_tonumber(thr, tv);  /* invalidates tv */
-+	d = duk__toint32_touint32_helper(d, 0);
-+	DUK_ASSERT(DUK_FPCLASSIFY(d) == DUK_FP_ZERO || DUK_FPCLASSIFY(d) == DUK_FP_NORMAL);
-+	DUK_ASSERT(d >= 0.0 && d <= 4294967295.0);  /* [0x00000000, 0xffffffff] */
-+	DUK_ASSERT(d == ((duk_double_t) ((duk_uint32_t) d)));  /* whole, won't clip */
-+	return (duk_uint32_t) d;
-+
-+}
-+
-+DUK_INTERNAL duk_uint16_t duk_js_touint16(duk_hthread *thr, duk_tval *tv) {
-+	/* should be a safe way to compute this */
-+	return (duk_uint16_t) (duk_js_touint32(thr, tv) & 0x0000ffffU);
-+}
-+
-+/*
-+ *  ToString()  (E5 Section 9.8)
-+ *
-+ *  ==> implemented in the API.
-+ */
-+
-+/*
-+ *  ToObject()  (E5 Section 9.9)
-+ *
-+ *  ==> implemented in the API.
-+ */
-+
-+/*
-+ *  CheckObjectCoercible()  (E5 Section 9.10)
-+ *
-+ *  Note: no API equivalent now.
-+ */
-+
-+#if 0  /* unused */
-+DUK_INTERNAL void duk_js_checkobjectcoercible(duk_hthread *thr, duk_tval *tv_x) {
-+	duk_small_uint_t tag = DUK_TVAL_GET_TAG(tv_x);
-+
-+	/* Note: this must match ToObject() behavior */
-+
-+	if (tag == DUK_TAG_UNDEFINED ||
-+	    tag == DUK_TAG_NULL ||
-+	    tag == DUK_TAG_POINTER ||
-+	    tag == DUK_TAG_BUFFER) {
-+		DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "not object coercible");
-+	}
-+}
-+#endif
-+
-+/*
-+ *  IsCallable()  (E5 Section 9.11)
-+ *
-+ *  XXX: API equivalent is a separate implementation now, and this has
-+ *  currently no callers.
-+ */
-+
-+#if 0  /* unused */
-+DUK_INTERNAL duk_bool_t duk_js_iscallable(duk_tval *tv_x) {
-+	duk_hobject *obj;
-+
-+	if (!DUK_TVAL_IS_OBJECT(tv_x)) {
-+		return 0;
-+	}
-+	obj = DUK_TVAL_GET_OBJECT(tv_x);
-+	DUK_ASSERT(obj != NULL);
-+
-+	return DUK_HOBJECT_IS_CALLABLE(obj);
-+}
-+#endif
-+
-+/*
-+ *  Loose equality, strict equality, and SameValue (E5 Sections 11.9.1, 11.9.4,
-+ *  9.12).  These have much in common so they can share some helpers.
-+ *
-+ *  Future work notes:
-+ *
-+ *    - Current implementation (and spec definition) has recursion; this should
-+ *      be fixed if possible.
-+ *
-+ *    - String-to-number coercion should be possible without going through the
-+ *      value stack (and be more compact) if a shared helper is invoked.
-+ */
-+
-+/* Note that this is the same operation for strict and loose equality:
-+ *  - E5 Section 11.9.3, step 1.c (loose)
-+ *  - E5 Section 11.9.6, step 4 (strict)
-+ */
-+
-+DUK_LOCAL duk_bool_t duk__js_equals_number(duk_double_t x, duk_double_t y) {
-+#if defined(DUK_USE_PARANOID_MATH)
-+	/* Straightforward algorithm, makes fewer compiler assumptions. */
-+	duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
-+	duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
-+	if (cx == DUK_FP_NAN || cy == DUK_FP_NAN) {
-+		return 0;
-+	}
-+	if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) {
-+		return 1;
-+	}
-+	if (x == y) {
-+		return 1;
-+	}
-+	return 0;
-+#else  /* DUK_USE_PARANOID_MATH */
-+	/* Better equivalent algorithm.  If the compiler is compliant, C and
-+	 * Ecmascript semantics are identical for this particular comparison.
-+	 * In particular, NaNs must never compare equal and zeroes must compare
-+	 * equal regardless of sign.  Could also use a macro, but this inlines
-+	 * already nicely (no difference on gcc, for instance).
-+	 */
-+	if (x == y) {
-+		/* IEEE requires that NaNs compare false */
-+		DUK_ASSERT(DUK_FPCLASSIFY(x) != DUK_FP_NAN);
-+		DUK_ASSERT(DUK_FPCLASSIFY(y) != DUK_FP_NAN);
-+		return 1;
-+	} else {
-+		/* IEEE requires that zeros compare the same regardless
-+		 * of their signed, so if both x and y are zeroes, they
-+		 * are caught above.
-+		 */
-+		DUK_ASSERT(!(DUK_FPCLASSIFY(x) == DUK_FP_ZERO && DUK_FPCLASSIFY(y) == DUK_FP_ZERO));
-+		return 0;
-+	}
-+#endif  /* DUK_USE_PARANOID_MATH */
-+}
-+
-+DUK_LOCAL duk_bool_t duk__js_samevalue_number(duk_double_t x, duk_double_t y) {
-+#if defined(DUK_USE_PARANOID_MATH)
-+	duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
-+	duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
-+
-+	if (cx == DUK_FP_NAN && cy == DUK_FP_NAN) {
-+		/* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */
-+		return 1;
-+	}
-+	if (cx == DUK_FP_ZERO && cy == DUK_FP_ZERO) {
-+		/* Note: cannot assume that a non-zero return value of signbit() would
-+		 * always be the same -- hence cannot (portably) use something like:
-+		 *
-+		 *     signbit(x) == signbit(y)
-+		 */
-+		duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0);
-+		duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0);
-+		return (sx == sy);
-+	}
-+
-+	/* normal comparison; known:
-+	 *   - both x and y are not NaNs (but one of them can be)
-+	 *   - both x and y are not zero (but one of them can be)
-+	 *   - x and y may be denormal or infinite
-+	 */
-+
-+	return (x == y);
-+#else  /* DUK_USE_PARANOID_MATH */
-+	duk_small_int_t cx = (duk_small_int_t) DUK_FPCLASSIFY(x);
-+	duk_small_int_t cy = (duk_small_int_t) DUK_FPCLASSIFY(y);
-+
-+	if (x == y) {
-+		/* IEEE requires that NaNs compare false */
-+		DUK_ASSERT(DUK_FPCLASSIFY(x) != DUK_FP_NAN);
-+		DUK_ASSERT(DUK_FPCLASSIFY(y) != DUK_FP_NAN);
-+
-+		/* Using classification has smaller footprint than direct comparison. */
-+		if (DUK_UNLIKELY(cx == DUK_FP_ZERO && cy == DUK_FP_ZERO)) {
-+			/* Note: cannot assume that a non-zero return value of signbit() would
-+			 * always be the same -- hence cannot (portably) use something like:
-+			 *
-+			 *     signbit(x) == signbit(y)
-+			 */
-+			duk_small_int_t sx = (DUK_SIGNBIT(x) ? 1 : 0);
-+			duk_small_int_t sy = (DUK_SIGNBIT(y) ? 1 : 0);
-+			return (sx == sy);
-+		}
-+		return 1;
-+	} else {
-+		/* IEEE requires that zeros compare the same regardless
-+		 * of their signed, so if both x and y are zeroes, they
-+		 * are caught above.
-+		 */
-+		DUK_ASSERT(!(DUK_FPCLASSIFY(x) == DUK_FP_ZERO && DUK_FPCLASSIFY(y) == DUK_FP_ZERO));
-+
-+		/* Difference to non-strict/strict comparison is that NaNs compare
-+		 * equal and signed zero signs matter.
-+		 */
-+		if (DUK_UNLIKELY(cx == DUK_FP_NAN && cy == DUK_FP_NAN)) {
-+			/* SameValue(NaN, NaN) = true, regardless of NaN sign or extra bits */
-+			return 1;
-+		}
-+		return 0;
-+	}
-+#endif  /* DUK_USE_PARANOID_MATH */
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_tval *tv_tmp;
-+
-+	/* If flags != 0 (strict or SameValue), thr can be NULL.  For loose
-+	 * equals comparison it must be != NULL.
-+	 */
-+	DUK_ASSERT(flags != 0 || thr != NULL);
-+
-+	/*
-+	 *  Same type?
-+	 *
-+	 *  Note: since number values have no explicit tag in the 8-byte
-+	 *  representation, need the awkward if + switch.
-+	 */
-+
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
-+		if (DUK_TVAL_GET_FASTINT(tv_x) == DUK_TVAL_GET_FASTINT(tv_y)) {
-+			return 1;
-+		} else {
-+			return 0;
-+		}
-+	}
-+	else
-+#endif
-+	if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
-+		/* Catches both doubles and cases where only one argument is a fastint */
-+		if (DUK_UNLIKELY((flags & DUK_EQUALS_FLAG_SAMEVALUE) != 0)) {
-+			/* SameValue */
-+			return duk__js_samevalue_number(DUK_TVAL_GET_NUMBER(tv_x),
-+			                                DUK_TVAL_GET_NUMBER(tv_y));
-+		} else {
-+			/* equals and strict equals */
-+			return duk__js_equals_number(DUK_TVAL_GET_NUMBER(tv_x),
-+			                             DUK_TVAL_GET_NUMBER(tv_y));
-+		}
-+	} else if (DUK_TVAL_GET_TAG(tv_x) == DUK_TVAL_GET_TAG(tv_y)) {
-+		switch (DUK_TVAL_GET_TAG(tv_x)) {
-+		case DUK_TAG_UNDEFINED:
-+		case DUK_TAG_NULL: {
-+			return 1;
-+		}
-+		case DUK_TAG_BOOLEAN: {
-+			return DUK_TVAL_GET_BOOLEAN(tv_x) == DUK_TVAL_GET_BOOLEAN(tv_y);
-+		}
-+		case DUK_TAG_POINTER: {
-+			return DUK_TVAL_GET_POINTER(tv_x) == DUK_TVAL_GET_POINTER(tv_y);
-+		}
-+		case DUK_TAG_STRING:
-+		case DUK_TAG_OBJECT: {
-+			/* heap pointer comparison suffices */
-+			return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y);
-+		}
-+		case DUK_TAG_BUFFER: {
-+			if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) {
-+				/* heap pointer comparison suffices */
-+				return DUK_TVAL_GET_HEAPHDR(tv_x) == DUK_TVAL_GET_HEAPHDR(tv_y);
-+			} else {
-+				/* non-strict equality for buffers compares contents */
-+				duk_hbuffer *h_x = DUK_TVAL_GET_BUFFER(tv_x);
-+				duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y);
-+				duk_size_t len_x = DUK_HBUFFER_GET_SIZE(h_x);
-+				duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y);
-+				void *buf_x;
-+				void *buf_y;
-+				if (len_x != len_y) {
-+					return 0;
-+				}
-+				buf_x = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_x);
-+				buf_y = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y);
-+				/* if len_x == len_y == 0, buf_x and/or buf_y may
-+				 * be NULL, but that's OK.
-+				 */
-+				DUK_ASSERT(len_x == len_y);
-+				DUK_ASSERT(len_x == 0 || buf_x != NULL);
-+				DUK_ASSERT(len_y == 0 || buf_y != NULL);
-+				return (DUK_MEMCMP(buf_x, buf_y, len_x) == 0) ? 1 : 0;
-+			}
-+		}
-+		case DUK_TAG_LIGHTFUNC: {
-+			/* At least 'magic' has a significant impact on function
-+			 * identity.
-+			 */
-+			duk_small_uint_t lf_flags_x;
-+			duk_small_uint_t lf_flags_y;
-+			duk_c_function func_x;
-+			duk_c_function func_y;
-+
-+			DUK_TVAL_GET_LIGHTFUNC(tv_x, func_x, lf_flags_x);
-+			DUK_TVAL_GET_LIGHTFUNC(tv_y, func_y, lf_flags_y);
-+			return ((func_x == func_y) && (lf_flags_x == lf_flags_y)) ? 1 : 0;
-+		}
-+#if defined(DUK_USE_FASTINT)
-+		case DUK_TAG_FASTINT:
-+#endif
-+		default: {
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x));
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_y));
-+			DUK_UNREACHABLE();
-+			return 0;
-+		}
-+		}
-+	}
-+
-+	if ((flags & (DUK_EQUALS_FLAG_STRICT | DUK_EQUALS_FLAG_SAMEVALUE)) != 0) {
-+		return 0;
-+	}
-+
-+	DUK_ASSERT(flags == 0);  /* non-strict equality from here on */
-+
-+	/*
-+	 *  Types are different; various cases for non-strict comparison
-+	 *
-+	 *  Since comparison is symmetric, we use a "swap trick" to reduce
-+	 *  code size.
-+	 */
-+
-+	/* Undefined/null are considered equal (e.g. "null == undefined" -> true). */
-+	if ((DUK_TVAL_IS_UNDEFINED(tv_x) && DUK_TVAL_IS_NULL(tv_y)) ||
-+	    (DUK_TVAL_IS_NULL(tv_x) && DUK_TVAL_IS_UNDEFINED(tv_y))) {
-+		return 1;
-+	}
-+
-+	/* Number/string-or-buffer -> coerce string to number (e.g. "'1.5' == 1.5" -> true). */
-+	if (DUK_TVAL_IS_NUMBER(tv_x) && (DUK_TVAL_IS_STRING(tv_y) || DUK_TVAL_IS_BUFFER(tv_y))) {
-+		/* the next 'if' is guaranteed to match after swap */
-+		tv_tmp = tv_x;
-+		tv_x = tv_y;
-+		tv_y = tv_tmp;
-+	}
-+	if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) && DUK_TVAL_IS_NUMBER(tv_y)) {
-+		/* XXX: this is possible without resorting to the value stack */
-+		duk_double_t d1, d2;
-+		d2 = DUK_TVAL_GET_NUMBER(tv_y);
-+		duk_push_tval(ctx, tv_x);
-+		duk_to_string(ctx, -1);  /* buffer values are coerced first to string here */
-+		duk_to_number(ctx, -1);
-+		d1 = duk_require_number(ctx, -1);
-+		duk_pop(ctx);
-+		return duk__js_equals_number(d1, d2);
-+	}
-+
-+	/* Buffer/string -> compare contents. */
-+	if (DUK_TVAL_IS_BUFFER(tv_x) && DUK_TVAL_IS_STRING(tv_y)) {
-+		tv_tmp = tv_x;
-+		tv_x = tv_y;
-+		tv_y = tv_tmp;
-+	}
-+	if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_BUFFER(tv_y)) {
-+		duk_hstring *h_x = DUK_TVAL_GET_STRING(tv_x);
-+		duk_hbuffer *h_y = DUK_TVAL_GET_BUFFER(tv_y);
-+		duk_size_t len_x = DUK_HSTRING_GET_BYTELEN(h_x);
-+		duk_size_t len_y = DUK_HBUFFER_GET_SIZE(h_y);
-+		void *buf_x;
-+		void *buf_y;
-+		if (len_x != len_y) {
-+			return 0;
-+		}
-+		buf_x = (void *) DUK_HSTRING_GET_DATA(h_x);
-+		buf_y = (void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h_y);
-+		/* if len_x == len_y == 0, buf_x and/or buf_y may
-+		 * be NULL, but that's OK.
-+		 */
-+		DUK_ASSERT(len_x == len_y);
-+		DUK_ASSERT(len_x == 0 || buf_x != NULL);
-+		DUK_ASSERT(len_y == 0 || buf_y != NULL);
-+		return (DUK_MEMCMP(buf_x, buf_y, len_x) == 0) ? 1 : 0;
-+	}
-+
-+	/* Boolean/any -> coerce boolean to number and try again.  If boolean is
-+	 * compared to a pointer, the final comparison after coercion now always
-+	 * yields false (as pointer vs. number compares to false), but this is
-+	 * not special cased.
-+	 */
-+	if (DUK_TVAL_IS_BOOLEAN(tv_x)) {
-+		tv_tmp = tv_x;
-+		tv_x = tv_y;
-+		tv_y = tv_tmp;
-+	}
-+	if (DUK_TVAL_IS_BOOLEAN(tv_y)) {
-+		/* ToNumber(bool) is +1.0 or 0.0.  Tagged boolean value is always 0 or 1. */
-+		duk_bool_t rc;
-+		DUK_ASSERT(DUK_TVAL_GET_BOOLEAN(tv_y) == 0 || DUK_TVAL_GET_BOOLEAN(tv_y) == 1);
-+		duk_push_tval(ctx, tv_x);
-+		duk_push_int(ctx, DUK_TVAL_GET_BOOLEAN(tv_y));
-+		rc = duk_js_equals_helper(thr, duk_get_tval(ctx, -2), duk_get_tval(ctx, -1), 0 /*flags:nonstrict*/);
-+		duk_pop_2(ctx);
-+		return rc;
-+	}
-+
-+	/* String-number-buffer/object -> coerce object to primitive (apparently without hint), then try again. */
-+	if ((DUK_TVAL_IS_STRING(tv_x) || DUK_TVAL_IS_NUMBER(tv_x) || DUK_TVAL_IS_BUFFER(tv_x)) &&
-+	    DUK_TVAL_IS_OBJECT(tv_y)) {
-+		tv_tmp = tv_x;
-+		tv_x = tv_y;
-+		tv_y = tv_tmp;
-+	}
-+	if (DUK_TVAL_IS_OBJECT(tv_x) &&
-+	    (DUK_TVAL_IS_STRING(tv_y) || DUK_TVAL_IS_NUMBER(tv_y) || DUK_TVAL_IS_BUFFER(tv_y))) {
-+		duk_bool_t rc;
-+		duk_push_tval(ctx, tv_x);
-+		duk_push_tval(ctx, tv_y);
-+		duk_to_primitive(ctx, -2, DUK_HINT_NONE);  /* apparently no hint? */
-+		rc = duk_js_equals_helper(thr, duk_get_tval(ctx, -2), duk_get_tval(ctx, -1), 0 /*flags:nonstrict*/);
-+		duk_pop_2(ctx);
-+		return rc;
-+	}
-+
-+	/* Nothing worked -> not equal. */
-+	return 0;
-+}
-+
-+/*
-+ *  Comparisons (x >= y, x > y, x <= y, x < y)
-+ *
-+ *  E5 Section 11.8.5: implement 'x < y' and then use negate and eval_left_first
-+ *  flags to get the rest.
-+ */
-+
-+/* XXX: this should probably just operate on the stack top, because it
-+ * needs to push stuff on the stack anyway...
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2) {
-+	/*
-+	 *  String comparison (E5 Section 11.8.5, step 4), which
-+	 *  needs to compare codepoint by codepoint.
-+	 *
-+	 *  However, UTF-8 allows us to use strcmp directly: the shared
-+	 *  prefix will be encoded identically (UTF-8 has unique encoding)
-+	 *  and the first differing character can be compared with a simple
-+	 *  unsigned byte comparison (which strcmp does).
-+	 *
-+	 *  This will not work properly for non-xutf-8 strings, but this
-+	 *  is not an issue for compliance.
-+	 */
-+
-+	duk_size_t h1_len, h2_len, prefix_len;
-+	duk_small_int_t rc;
-+
-+	DUK_ASSERT(h1 != NULL);
-+	DUK_ASSERT(h2 != NULL);
-+	h1_len = DUK_HSTRING_GET_BYTELEN(h1);
-+	h2_len = DUK_HSTRING_GET_BYTELEN(h2);
-+	prefix_len = (h1_len <= h2_len ? h1_len : h2_len);
-+
-+	/* XXX: this special case can now be removed with DUK_MEMCMP */
-+	/* memcmp() should return zero (equal) for zero length, but avoid
-+	 * it because there are some platform specific bugs.  Don't use
-+	 * strncmp() because it stops comparing at a NUL.
-+	 */
-+
-+	if (prefix_len == 0) {
-+		rc = 0;
-+	} else {
-+		rc = DUK_MEMCMP((const char *) DUK_HSTRING_GET_DATA(h1),
-+		                (const char *) DUK_HSTRING_GET_DATA(h2),
-+		                prefix_len);
-+	}
-+
-+	if (rc < 0) {
-+		return -1;
-+	} else if (rc > 0) {
-+		return 1;
-+	}
-+
-+	/* prefix matches, lengths matter now */
-+	if (h1_len < h2_len) {
-+		/* e.g. "x" < "xx" */
-+		return -1;
-+	} else if (h1_len > h2_len) {
-+		return 1;
-+	}
-+
-+	return 0;
-+}
-+
-+DUK_INTERNAL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_int_t flags) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_double_t d1, d2;
-+	duk_small_int_t c1, c2;
-+	duk_small_int_t s1, s2;
-+	duk_small_int_t rc;
-+	duk_bool_t retval;
-+
-+	/* Fast path for fastints */
-+#if defined(DUK_USE_FASTINT)
-+	if (DUK_TVAL_IS_FASTINT(tv_x) && DUK_TVAL_IS_FASTINT(tv_y)) {
-+		duk_int64_t v1 = DUK_TVAL_GET_FASTINT(tv_x);
-+		duk_int64_t v2 = DUK_TVAL_GET_FASTINT(tv_y);
-+		if (v1 < v2) {
-+			/* 'lt is true' */
-+			retval = 1;
-+		} else {
-+			retval = 0;
-+		}
-+		if (flags & DUK_COMPARE_FLAG_NEGATE) {
-+			retval ^= 1;
-+		}
-+		return retval;
-+	}
-+#endif  /* DUK_USE_FASTINT */
-+
-+	/* Fast path for numbers (one of which may be a fastint) */
-+#if 1  /* XXX: make fast paths optional for size minimization? */
-+	if (DUK_TVAL_IS_NUMBER(tv_x) && DUK_TVAL_IS_NUMBER(tv_y)) {
-+		d1 = DUK_TVAL_GET_NUMBER(tv_x);
-+		d2 = DUK_TVAL_GET_NUMBER(tv_y);
-+		c1 = DUK_FPCLASSIFY(d1);
-+		c2 = DUK_FPCLASSIFY(d2);
-+
-+		if (c1 == DUK_FP_NORMAL && c2 == DUK_FP_NORMAL) {
-+			/* XXX: this is a very narrow check, and doesn't cover
-+			 * zeroes, subnormals, infinities, which compare normally.
-+			 */
-+
-+			if (d1 < d2) {
-+				/* 'lt is true' */
-+				retval = 1;
-+			} else {
-+				retval = 0;
-+			}
-+			if (flags & DUK_COMPARE_FLAG_NEGATE) {
-+				retval ^= 1;
-+			}
-+			return retval;
-+		}
-+	}
-+#endif
-+
-+	/* Slow path */
-+
-+	duk_push_tval(ctx, tv_x);
-+	duk_push_tval(ctx, tv_y);
-+
-+	if (flags & DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) {
-+		duk_to_primitive(ctx, -2, DUK_HINT_NUMBER);
-+		duk_to_primitive(ctx, -1, DUK_HINT_NUMBER);
-+	} else {
-+		duk_to_primitive(ctx, -1, DUK_HINT_NUMBER);
-+		duk_to_primitive(ctx, -2, DUK_HINT_NUMBER);
-+	}
-+
-+	/* Note: reuse variables */
-+	tv_x = duk_get_tval(ctx, -2);
-+	tv_y = duk_get_tval(ctx, -1);
-+
-+	if (DUK_TVAL_IS_STRING(tv_x) && DUK_TVAL_IS_STRING(tv_y)) {
-+		duk_hstring *h1 = DUK_TVAL_GET_STRING(tv_x);
-+		duk_hstring *h2 = DUK_TVAL_GET_STRING(tv_y);
-+		DUK_ASSERT(h1 != NULL);
-+		DUK_ASSERT(h2 != NULL);
-+
-+		rc = duk_js_string_compare(h1, h2);
-+		if (rc < 0) {
-+			goto lt_true;
-+		} else {
-+			goto lt_false;
-+		}
-+	} else {
-+		/* Ordering should not matter (E5 Section 11.8.5, step 3.a) but
-+		 * preserve it just in case.
-+		 */
-+
-+		if (flags & DUK_COMPARE_FLAG_EVAL_LEFT_FIRST) {
-+			d1 = duk_to_number(ctx, -2);
-+			d2 = duk_to_number(ctx, -1);
-+		} else {
-+			d2 = duk_to_number(ctx, -1);
-+			d1 = duk_to_number(ctx, -2);
-+		}
-+
-+		c1 = (duk_small_int_t) DUK_FPCLASSIFY(d1);
-+		s1 = (duk_small_int_t) DUK_SIGNBIT(d1);
-+		c2 = (duk_small_int_t) DUK_FPCLASSIFY(d2);
-+		s2 = (duk_small_int_t) DUK_SIGNBIT(d2);
-+
-+		if (c1 == DUK_FP_NAN || c2 == DUK_FP_NAN) {
-+			goto lt_undefined;
-+		}
-+
-+		if (c1 == DUK_FP_ZERO && c2 == DUK_FP_ZERO) {
-+			/* For all combinations: +0 < +0, +0 < -0, -0 < +0, -0 < -0,
-+			 * steps e, f, and g.
-+			 */
-+			goto lt_false;
-+		}
-+
-+		if (d1 == d2) {
-+			goto lt_false;
-+		}
-+
-+		if (c1 == DUK_FP_INFINITE && s1 == 0) {
-+			/* x == +Infinity */
-+			goto lt_false;
-+		}
-+
-+		if (c2 == DUK_FP_INFINITE && s2 == 0) {
-+			/* y == +Infinity */
-+			goto lt_true;
-+		}
-+
-+		if (c2 == DUK_FP_INFINITE && s2 != 0) {
-+			/* y == -Infinity */
-+			goto lt_false;
-+		}
-+
-+		if (c1 == DUK_FP_INFINITE && s1 != 0) {
-+			/* x == -Infinity */
-+			goto lt_true;
-+		}
-+
-+		if (d1 < d2) {
-+			goto lt_true;
-+		}
-+
-+		goto lt_false;
-+	}
-+
-+ lt_undefined:
-+	/* Note: undefined from Section 11.8.5 always results in false
-+	 * return (see e.g. Section 11.8.3) - hence special treatment here.
-+	 */
-+	retval = 0;
-+	goto cleanup;
-+
-+ lt_true:
-+	if (flags & DUK_COMPARE_FLAG_NEGATE) {
-+		retval = 0;
-+		goto cleanup;
-+	} else {
-+		retval = 1;
-+		goto cleanup;
-+	}
-+	/* never here */
-+
-+ lt_false:
-+	if (flags & DUK_COMPARE_FLAG_NEGATE) {
-+		retval = 1;
-+		goto cleanup;
-+	} else {
-+		retval = 0;
-+		goto cleanup;
-+	}
-+	/* never here */
-+
-+ cleanup:
-+	duk_pop_2(ctx);
-+	return retval;
-+}
-+
-+/*
-+ *  instanceof
-+ */
-+
-+/*
-+ *  E5 Section 11.8.6 describes the main algorithm, which uses
-+ *  [[HasInstance]].  [[HasInstance]] is defined for only
-+ *  function objects:
-+ *
-+ *    - Normal functions:
-+ *      E5 Section 15.3.5.3
-+ *    - Functions established with Function.prototype.bind():
-+ *      E5 Section 15.3.4.5.3
-+ *
-+ *  For other objects, a TypeError is thrown.
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_js_instanceof(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *func;
-+	duk_hobject *val;
-+	duk_hobject *proto;
-+	duk_uint_t sanity;
-+
-+	/*
-+	 *  Get the values onto the stack first.  It would be possible to cover
-+	 *  some normal cases without resorting to the value stack.
-+	 *
-+	 *  The right hand side could be a light function (as they generally
-+	 *  behave like objects).  Light functions never have a 'prototype'
-+	 *  property so E5.1 Section 15.3.5.3 step 3 always throws a TypeError.
-+	 *  Using duk_require_hobject() is thus correct (except for error msg).
-+	 */
-+
-+	duk_push_tval(ctx, tv_x);
-+	duk_push_tval(ctx, tv_y);
-+	func = duk_require_hobject(ctx, -1);
-+
-+	/*
-+	 *  For bound objects, [[HasInstance]] just calls the target function
-+	 *  [[HasInstance]].  If that is again a bound object, repeat until
-+	 *  we find a non-bound Function object.
-+	 */
-+
-+	/* XXX: this bound function resolution also happens elsewhere,
-+	 * move into a shared helper.
-+	 */
-+
-+	sanity = DUK_HOBJECT_BOUND_CHAIN_SANITY;
-+	do {
-+		/* check func supports [[HasInstance]] (this is checked for every function
-+		 * in the bound chain, including the final one)
-+		 */
-+
-+		if (!DUK_HOBJECT_IS_CALLABLE(func)) {
-+			/*
-+			 *  Note: of native Ecmascript objects, only Function instances
-+			 *  have a [[HasInstance]] internal property.  Custom objects might
-+			 *  also have it, but not in current implementation.
-+			 *
-+			 *  XXX: add a separate flag, DUK_HOBJECT_FLAG_ALLOW_INSTANCEOF?
-+			 */
-+			DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "invalid instanceof rval");
-+		}
-+
-+		if (!DUK_HOBJECT_HAS_BOUND(func)) {
-+			break;
-+		}
-+
-+		/* [ ... lval rval ] */
-+
-+		duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_TARGET);         /* -> [ ... lval rval new_rval ] */
-+		duk_replace(ctx, -1);                                        /* -> [ ... lval new_rval ] */
-+		func = duk_require_hobject(ctx, -1);
-+
-+		/* func support for [[HasInstance]] checked in the beginning of the loop */
-+	} while (--sanity > 0);
-+
-+	if (sanity == 0) {
-+		DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_BOUND_CHAIN_LIMIT);
-+	}
-+
-+	/*
-+	 *  'func' is now a non-bound object which supports [[HasInstance]]
-+	 *  (which here just means DUK_HOBJECT_FLAG_CALLABLE).  Move on
-+	 *  to execute E5 Section 15.3.5.3.
-+	 */
-+
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));
-+	DUK_ASSERT(DUK_HOBJECT_IS_CALLABLE(func));
-+
-+	/* [ ... lval rval(func) ] */
-+
-+	/* Handle lightfuncs through object coercion for now. */
-+	/* XXX: direct implementation */
-+	val = duk_get_hobject_or_lfunc_coerce(ctx, -2);
-+	if (!val) {
-+		goto pop_and_false;
-+	}
-+
-+	duk_get_prop_stridx(ctx, -1, DUK_STRIDX_PROTOTYPE);  /* -> [ ... lval rval rval.prototype ] */
-+	proto = duk_require_hobject(ctx, -1);
-+	duk_pop(ctx);  /* -> [ ... lval rval ] */
-+
-+	sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
-+	do {
-+		/*
-+		 *  Note: prototype chain is followed BEFORE first comparison.  This
-+		 *  means that the instanceof lval is never itself compared to the
-+		 *  rval.prototype property.  This is apparently intentional, see E5
-+		 *  Section 15.3.5.3, step 4.a.
-+		 *
-+		 *  Also note:
-+		 *
-+		 *      js> (function() {}) instanceof Function
-+		 *      true
-+		 *      js> Function instanceof Function
-+		 *      true
-+		 *
-+		 *  For the latter, h_proto will be Function.prototype, which is the
-+		 *  built-in Function prototype.  Because Function.[[Prototype]] is
-+		 *  also the built-in Function prototype, the result is true.
-+		 */
-+
-+		val = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, val);
-+
-+		if (!val) {
-+			goto pop_and_false;
-+		} else if (val == proto) {
-+			goto pop_and_true;
-+		}
-+
-+		/* follow prototype chain */
-+	} while (--sanity > 0);
-+
-+	if (sanity == 0) {
-+		DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
-+	}
-+	DUK_UNREACHABLE();
-+
-+ pop_and_false:
-+	duk_pop_2(ctx);
-+	return 0;
-+
-+ pop_and_true:
-+	duk_pop_2(ctx);
-+	return 1;
-+}
-+
-+/*
-+ *  in
-+ */
-+
-+/*
-+ *  E5 Sections 11.8.7, 8.12.6.
-+ *
-+ *  Basically just a property existence check using [[HasProperty]].
-+ */
-+
-+DUK_INTERNAL duk_bool_t duk_js_in(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_bool_t retval;
-+
-+	/*
-+	 *  Get the values onto the stack first.  It would be possible to cover
-+	 *  some normal cases without resorting to the value stack (e.g. if
-+	 *  lval is already a string).
-+	 */
-+
-+	/* XXX: The ES5/5.1/6 specifications require that the key in 'key in obj'
-+	 * must be string coerced before the internal HasProperty() algorithm is
-+	 * invoked.  A fast path skipping coercion could be safely implemented for
-+	 * numbers (as number-to-string coercion has no side effects).  For ES6
-+	 * proxy behavior, the trap 'key' argument must be in a string coerced
-+	 * form (which is a shame).
-+	 */
-+
-+	/* TypeError if rval is not an object (or lightfunc which should behave
-+	 * like a Function instance).
-+	 */
-+	duk_push_tval(ctx, tv_x);
-+	duk_push_tval(ctx, tv_y);
-+	duk_require_type_mask(ctx, -1, DUK_TYPE_MASK_OBJECT | DUK_TYPE_MASK_LIGHTFUNC);
-+	duk_to_string(ctx, -2);               /* coerce lval with ToString() */
-+
-+	retval = duk_hobject_hasprop(thr, duk_get_tval(ctx, -1), duk_get_tval(ctx, -2));
-+
-+	duk_pop_2(ctx);
-+	return retval;
-+}
-+
-+/*
-+ *  typeof
-+ *
-+ *  E5 Section 11.4.3.
-+ *
-+ *  Very straightforward.  The only question is what to return for our
-+ *  non-standard tag / object types.
-+ *
-+ *  There is an unfortunate string constant define naming problem with
-+ *  typeof return values for e.g. "Object" and "object"; careful with
-+ *  the built-in string defines.  The LC_XXX defines are used for the
-+ *  lowercase variants now.
-+ */
-+
-+DUK_INTERNAL duk_hstring *duk_js_typeof(duk_hthread *thr, duk_tval *tv_x) {
-+	duk_small_int_t stridx = 0;
-+
-+	switch (DUK_TVAL_GET_TAG(tv_x)) {
-+	case DUK_TAG_UNDEFINED: {
-+		stridx = DUK_STRIDX_LC_UNDEFINED;
-+		break;
-+	}
-+	case DUK_TAG_NULL: {
-+		/* Note: not a typo, "object" is returned for a null value */
-+		stridx = DUK_STRIDX_LC_OBJECT;
-+		break;
-+	}
-+	case DUK_TAG_BOOLEAN: {
-+		stridx = DUK_STRIDX_LC_BOOLEAN;
-+		break;
-+	}
-+	case DUK_TAG_POINTER: {
-+		/* implementation specific */
-+		stridx = DUK_STRIDX_LC_POINTER;
-+		break;
-+	}
-+	case DUK_TAG_STRING: {
-+		stridx = DUK_STRIDX_LC_STRING;
-+		break;
-+	}
-+	case DUK_TAG_OBJECT: {
-+		duk_hobject *obj = DUK_TVAL_GET_OBJECT(tv_x);
-+		DUK_ASSERT(obj != NULL);
-+		if (DUK_HOBJECT_IS_CALLABLE(obj)) {
-+			stridx = DUK_STRIDX_LC_FUNCTION;
-+		} else {
-+			stridx = DUK_STRIDX_LC_OBJECT;
-+		}
-+		break;
-+	}
-+	case DUK_TAG_BUFFER: {
-+		/* implementation specific */
-+		stridx = DUK_STRIDX_LC_BUFFER;
-+		break;
-+	}
-+	case DUK_TAG_LIGHTFUNC: {
-+		stridx = DUK_STRIDX_LC_FUNCTION;
-+		break;
-+	}
-+#if defined(DUK_USE_FASTINT)
-+	case DUK_TAG_FASTINT:
-+#endif
-+	default: {
-+		/* number */
-+		DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_x));
-+		stridx = DUK_STRIDX_LC_NUMBER;
-+		break;
-+	}
-+	}
-+
-+	DUK_ASSERT(stridx >= 0 && stridx < DUK_HEAP_NUM_STRINGS);
-+	return DUK_HTHREAD_GET_STRING(thr, stridx);
-+}
-+
-+/*
-+ *  Array index and length
-+ *
-+ *  Array index: E5 Section 15.4
-+ *  Array length: E5 Section 15.4.5.1 steps 3.c - 3.d (array length write)
-+ *
-+ *  The DUK_HSTRING_GET_ARRIDX_SLOW() and DUK_HSTRING_GET_ARRIDX_FAST() macros
-+ *  call duk_js_to_arrayindex_string_helper().
-+ */
-+
-+DUK_INTERNAL duk_small_int_t duk_js_to_arrayindex_raw_string(const duk_uint8_t *str, duk_uint32_t blen, duk_uarridx_t *out_idx) {
-+	duk_uarridx_t res, new_res;
-+
-+	if (blen == 0 || blen > 10) {
-+		goto parse_fail;
-+	}
-+	if (str[0] == (duk_uint8_t) '0' && blen > 1) {
-+		goto parse_fail;
-+	}
-+
-+	/* Accept 32-bit decimal integers, no leading zeroes, signs, etc.
-+	 * Leading zeroes are not accepted (zero index "0" is an exception
-+	 * handled above).
-+	 */
-+
-+	res = 0;
-+	while (blen-- > 0) {
-+		duk_uint8_t c = *str++;
-+		if (c >= (duk_uint8_t) '0' && c <= (duk_uint8_t) '9') {
-+			new_res = res * 10 + (duk_uint32_t) (c - (duk_uint8_t) '0');
-+			if (new_res < res) {
-+				/* overflow, more than 32 bits -> not an array index */
-+				goto parse_fail;
-+			}
-+			res = new_res;
-+		} else {
-+			goto parse_fail;
-+		}
-+	}
-+
-+	*out_idx = res;
-+	return 1;
-+
-+ parse_fail:
-+	*out_idx = DUK_HSTRING_NO_ARRAY_INDEX;
-+	return 0;
-+}
-+
-+/* Called by duk_hstring.h macros */
-+DUK_INTERNAL duk_uarridx_t duk_js_to_arrayindex_string_helper(duk_hstring *h) {
-+	duk_uarridx_t res;
-+	duk_small_int_t rc;
-+
-+	if (!DUK_HSTRING_HAS_ARRIDX(h)) {
-+		return DUK_HSTRING_NO_ARRAY_INDEX;
-+	}
-+
-+	rc = duk_js_to_arrayindex_raw_string(DUK_HSTRING_GET_DATA(h),
-+	                                     DUK_HSTRING_GET_BYTELEN(h),
-+	                                     &res);
-+	DUK_UNREF(rc);
-+	DUK_ASSERT(rc != 0);
-+	return res;
-+}
-+#line 1 "duk_js_var.c"
-+/*
-+ *  Identifier access and function closure handling.
-+ *
-+ *  Provides the primitives for slow path identifier accesses: GETVAR,
-+ *  PUTVAR, DELVAR, etc.  The fast path, direct register accesses, should
-+ *  be used for most identifier accesses.  Consequently, these slow path
-+ *  primitives should be optimized for maximum compactness.
-+ *
-+ *  Ecmascript environment records (declarative and object) are represented
-+ *  as internal objects with control keys.  Environment records have a
-+ *  parent record ("outer environment reference") which is represented by
-+ *  the implicit prototype for technical reasons (in other words, it is a
-+ *  convenient field).  The prototype chain is not followed in the ordinary
-+ *  sense for variable lookups.
-+ *
-+ *  See identifier-handling.txt for more details on the identifier algorithms
-+ *  and the internal representation.  See function-objects.txt for details on
-+ *  what function templates and instances are expected to look like.
-+ *
-+ *  Care must be taken to avoid duk_tval pointer invalidation caused by
-+ *  e.g. value stack or object resizing.
-+ *
-+ *  TODO: properties for function instances could be initialized much more
-+ *  efficiently by creating a property allocation for a certain size and
-+ *  filling in keys and values directly (and INCREFing both with "bulk incref"
-+ *  primitives.
-+ *
-+ *  XXX: duk_hobject_getprop() and duk_hobject_putprop() calls are a bit
-+ *  awkward (especially because they follow the prototype chain); rework
-+ *  if "raw" own property helpers are added.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Local result type for duk__get_identifier_reference() lookup.
-+ */
-+
-+typedef struct {
-+	duk_hobject *holder;      /* for object-bound identifiers */
-+	duk_tval *value;          /* for register-bound and declarative env identifiers */
-+	duk_int_t attrs;          /* property attributes for identifier (relevant if value != NULL) */
-+	duk_tval *this_binding;
-+	duk_hobject *env;
-+} duk__id_lookup_result;
-+
-+/*
-+ *  Create a new function object based on a "template function" which contains
-+ *  compiled bytecode, constants, etc, but lacks a lexical environment.
-+ *
-+ *  Ecmascript requires that each created closure is a separate object, with
-+ *  its own set of editable properties.  However, structured property values
-+ *  (such as the formal arguments list and the variable map) are shared.
-+ *  Also the bytecode, constants, and inner functions are shared.
-+ *
-+ *  See E5 Section 13.2 for detailed requirements on the function objects;
-+ *  there are no similar requirements for function "templates" which are an
-+ *  implementation dependent internal feature.  Also see function-objects.txt
-+ *  for a discussion on the function instance properties provided by this
-+ *  implementation.
-+ *
-+ *  Notes:
-+ *
-+ *   * Order of internal properties should match frequency of use, since the
-+ *     properties will be linearly scanned on lookup (functions usually don't
-+ *     have enough properties to warrant a hash part).
-+ *
-+ *   * The created closure is independent of its template; they do share the
-+ *     same 'data' buffer object, but the template object itself can be freed
-+ *     even if the closure object remains reachable.
-+ */
-+
-+DUK_LOCAL void duk__inc_data_inner_refcounts(duk_hthread *thr, duk_hcompiledfunction *f) {
-+	duk_tval *tv, *tv_end;
-+	duk_hobject **funcs, **funcs_end;
-+
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, f) != NULL);  /* compiled functions must be created 'atomically' */
-+	DUK_UNREF(thr);
-+
-+	tv = DUK_HCOMPILEDFUNCTION_GET_CONSTS_BASE(thr->heap, f);
-+	tv_end = DUK_HCOMPILEDFUNCTION_GET_CONSTS_END(thr->heap, f);
-+	while (tv < tv_end) {
-+		DUK_TVAL_INCREF(thr, tv);
-+		tv++;
-+	}
-+
-+	funcs = DUK_HCOMPILEDFUNCTION_GET_FUNCS_BASE(thr->heap, f);
-+	funcs_end = DUK_HCOMPILEDFUNCTION_GET_FUNCS_END(thr->heap, f);
-+	while (funcs < funcs_end) {
-+		DUK_HEAPHDR_INCREF(thr, (duk_heaphdr *) *funcs);
-+		funcs++;
-+	}
-+}
-+
-+/* Push a new closure on the stack.
-+ *
-+ * Note: if fun_temp has NEWENV, i.e. a new lexical and variable declaration
-+ * is created when the function is called, only outer_lex_env matters
-+ * (outer_var_env is ignored and may or may not be same as outer_lex_env).
-+ */
-+
-+DUK_LOCAL const duk_uint16_t duk__closure_copy_proplist[] = {
-+	/* order: most frequent to least frequent */
-+	DUK_STRIDX_INT_VARMAP,
-+	DUK_STRIDX_INT_FORMALS,
-+	DUK_STRIDX_NAME,
-+	DUK_STRIDX_INT_PC2LINE,
-+	DUK_STRIDX_FILE_NAME,
-+	DUK_STRIDX_INT_SOURCE
-+};
-+
-+DUK_INTERNAL
-+void duk_js_push_closure(duk_hthread *thr,
-+                         duk_hcompiledfunction *fun_temp,
-+                         duk_hobject *outer_var_env,
-+                         duk_hobject *outer_lex_env) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hcompiledfunction *fun_clos;
-+	duk_small_uint_t i;
-+	duk_uint_t len_value;
-+
-+	DUK_ASSERT(fun_temp != NULL);
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_temp) != NULL);
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_temp) != NULL);
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_temp) != NULL);
-+	DUK_ASSERT(outer_var_env != NULL);
-+	DUK_ASSERT(outer_lex_env != NULL);
-+
-+	duk_push_compiledfunction(ctx);
-+	duk_push_hobject(ctx, &fun_temp->obj);  /* -> [ ... closure template ] */
-+
-+	fun_clos = (duk_hcompiledfunction *) duk_get_hcompiledfunction(ctx, -2);
-+	DUK_ASSERT(fun_clos != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION((duk_hobject *) fun_clos));
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos) == NULL);
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_clos) == NULL);
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_clos) == NULL);
-+
-+	DUK_HCOMPILEDFUNCTION_SET_DATA(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_temp));
-+	DUK_HCOMPILEDFUNCTION_SET_FUNCS(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_temp));
-+	DUK_HCOMPILEDFUNCTION_SET_BYTECODE(thr->heap, fun_clos, DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_temp));
-+
-+	/* Note: all references inside 'data' need to get their refcounts
-+	 * upped too.  This is the case because refcounts are decreased
-+	 * through every function referencing 'data' independently.
-+	 */
-+
-+	DUK_HBUFFER_INCREF(thr, DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos));
-+	duk__inc_data_inner_refcounts(thr, fun_temp);
-+
-+	fun_clos->nregs = fun_temp->nregs;
-+	fun_clos->nargs = fun_temp->nargs;
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+	fun_clos->start_line = fun_temp->start_line;
-+	fun_clos->end_line = fun_temp->end_line;
-+#endif
-+
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_DATA(thr->heap, fun_clos) != NULL);
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_FUNCS(thr->heap, fun_clos) != NULL);
-+	DUK_ASSERT(DUK_HCOMPILEDFUNCTION_GET_BYTECODE(thr->heap, fun_clos) != NULL);
-+
-+	/* XXX: could also copy from template, but there's no way to have any
-+	 * other value here now (used code has no access to the template).
-+	 */
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, &fun_clos->obj, thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
-+
-+	/*
-+	 *  Init/assert flags, copying them where appropriate.  Some flags
-+	 *  (like NEWENV) are processed separately below.
-+	 */
-+
-+	/* XXX: copy flags using a mask */
-+
-+	DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(&fun_clos->obj));
-+	DUK_HOBJECT_SET_CONSTRUCTABLE(&fun_clos->obj);  /* Note: not set in template (has no "prototype") */
-+	DUK_ASSERT(DUK_HOBJECT_HAS_CONSTRUCTABLE(&fun_clos->obj));
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(&fun_clos->obj));
-+	DUK_ASSERT(DUK_HOBJECT_HAS_COMPILEDFUNCTION(&fun_clos->obj));
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_NATIVEFUNCTION(&fun_clos->obj));
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_THREAD(&fun_clos->obj));
-+	/* DUK_HOBJECT_FLAG_ARRAY_PART: don't care */
-+	if (DUK_HOBJECT_HAS_STRICT(&fun_temp->obj)) {
-+		DUK_HOBJECT_SET_STRICT(&fun_clos->obj);
-+	}
-+	if (DUK_HOBJECT_HAS_NOTAIL(&fun_temp->obj)) {
-+		DUK_HOBJECT_SET_NOTAIL(&fun_clos->obj);
-+	}
-+	/* DUK_HOBJECT_FLAG_NEWENV: handled below */
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(&fun_clos->obj));
-+	if (DUK_HOBJECT_HAS_CREATEARGS(&fun_temp->obj)) {
-+		DUK_HOBJECT_SET_CREATEARGS(&fun_clos->obj);
-+	}
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(&fun_clos->obj));
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(&fun_clos->obj));
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(&fun_clos->obj));
-+
-+	/*
-+	 *  Setup environment record properties based on the template and
-+	 *  its flags.
-+	 *
-+	 *  If DUK_HOBJECT_HAS_NEWENV(fun_temp) is true, the environment
-+	 *  records represent identifiers "outside" the function; the
-+	 *  "inner" environment records are created on demand.  Otherwise,
-+	 *  the environment records are those that will be directly used
-+	 *  (e.g. for declarations).
-+	 *
-+	 *  _Lexenv is always set; _Varenv defaults to _Lexenv if missing,
-+	 *  so _Varenv is only set if _Lexenv != _Varenv.
-+	 *
-+	 *  This is relatively complex, see doc/identifier-handling.txt.
-+	 */
-+
-+	if (DUK_HOBJECT_HAS_NEWENV(&fun_temp->obj)) {
-+		DUK_HOBJECT_SET_NEWENV(&fun_clos->obj);
-+
-+		if (DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj)) {
-+			duk_hobject *proto;
-+
-+			/*
-+			 *  Named function expression, name needs to be bound
-+			 *  in an intermediate environment record.  The "outer"
-+			 *  lexical/variable environment will thus be:
-+			 *
-+			 *  a) { funcname: <func>, __prototype: outer_lex_env }
-+			 *  b) { funcname: <func>, __prototype:  <globalenv> }  (if outer_lex_env missing)
-+			 */
-+
-+			DUK_ASSERT(duk_has_prop_stridx(ctx, -1, DUK_STRIDX_NAME));  /* required if NAMEBINDING set */
-+
-+			if (outer_lex_env) {
-+				proto = outer_lex_env;
-+			} else {
-+				proto = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+			}
-+
-+			/* -> [ ... closure template env ] */
-+			(void) duk_push_object_helper_proto(ctx,
-+			                                    DUK_HOBJECT_FLAG_EXTENSIBLE |
-+			                                    DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
-+			                                    proto);
-+
-+			/* It's important that duk_xdef_prop() is a 'raw define' so that any
-+			 * properties in an ancestor are never an issue (they should never be
-+			 * e.g. non-writable, but just in case).
-+			 */
-+			duk_get_prop_stridx(ctx, -2, DUK_STRIDX_NAME);       /* -> [ ... closure template env funcname ] */
-+			duk_dup(ctx, -4);                                    /* -> [ ... closure template env funcname closure ] */
-+			duk_xdef_prop(ctx, -3, DUK_PROPDESC_FLAGS_NONE);     /* -> [ ... closure template env ] */
-+			/* env[funcname] = closure */
-+
-+			/* [ ... closure template env ] */
-+
-+			duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC);
-+			/* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
-+			 * will be ignored anyway
-+			 */
-+
-+			/* [ ... closure template ] */
-+		} else {
-+			/*
-+			 *  Other cases (function declaration, anonymous function expression,
-+			 *  strict direct eval code).  The "outer" environment will be whatever
-+			 *  the caller gave us.
-+			 */
-+
-+			duk_push_hobject(ctx, outer_lex_env);  /* -> [ ... closure template env ] */
-+			duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC);
-+			/* since closure has NEWENV, never define DUK_STRIDX_INT_VARENV, as it
-+			 * will be ignored anyway
-+			 */
-+
-+			/* [ ... closure template ] */
-+		}
-+	} else {
-+		/*
-+		 *  Function gets no new environment when called.  This is the
-+		 *  case for global code, indirect eval code, and non-strict
-+		 *  direct eval code.  There is no direct correspondence to the
-+		 *  E5 specification, as global/eval code is not exposed as a
-+		 *  function.
-+		 */
-+
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_NAMEBINDING(&fun_temp->obj));
-+
-+		duk_push_hobject(ctx, outer_lex_env);  /* -> [ ... closure template env ] */
-+		duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV, DUK_PROPDESC_FLAGS_WC);
-+
-+		if (outer_var_env != outer_lex_env) {
-+			duk_push_hobject(ctx, outer_var_env);  /* -> [ ... closure template env ] */
-+			duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_VARENV, DUK_PROPDESC_FLAGS_WC);
-+		}
-+	}
-+#ifdef DUK_USE_DDDPRINT
-+	duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_VARENV);
-+	duk_get_prop_stridx(ctx, -3, DUK_STRIDX_INT_LEXENV);
-+	DUK_DDD(DUK_DDDPRINT("closure varenv -> %!ipT, lexenv -> %!ipT",
-+	                     (duk_tval *) duk_get_tval(ctx, -2),
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+	duk_pop_2(ctx);
-+#endif
-+
-+	/*
-+	 *  Copy some internal properties directly
-+	 *
-+	 *  The properties will be writable and configurable, but not enumerable.
-+	 */
-+
-+	/* [ ... closure template ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("copying properties: closure=%!iT, template=%!iT",
-+	                     (duk_tval *) duk_get_tval(ctx, -2),
-+	                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	for (i = 0; i < (duk_small_uint_t) (sizeof(duk__closure_copy_proplist) / sizeof(duk_uint16_t)); i++) {
-+		duk_small_int_t stridx = (duk_small_int_t) duk__closure_copy_proplist[i];
-+		if (duk_get_prop_stridx(ctx, -1, stridx)) {
-+			/* [ ... closure template val ] */
-+			DUK_DDD(DUK_DDDPRINT("copying property, stridx=%ld -> found", (long) stridx));
-+			duk_xdef_prop_stridx(ctx, -3, stridx, DUK_PROPDESC_FLAGS_WC);
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("copying property, stridx=%ld -> not found", (long) stridx));
-+			duk_pop(ctx);
-+		}
-+	}
-+
-+	/*
-+	 *  "length" maps to number of formals (E5 Section 13.2) for function
-+	 *  declarations/expressions (non-bound functions).  Note that 'nargs'
-+	 *  is NOT necessarily equal to the number of arguments.
-+	 */
-+
-+	/* [ ... closure template ] */
-+
-+	len_value = 0;
-+
-+	/* XXX: use helper for size optimization */
-+	if (duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_FORMALS)) {
-+		/* [ ... closure template formals ] */
-+		DUK_ASSERT(duk_has_prop_stridx(ctx, -1, DUK_STRIDX_LENGTH));
-+		DUK_ASSERT(duk_get_length(ctx, -1) <= DUK_UINT_MAX);  /* formal arg limits */
-+		len_value = (duk_uint_t) duk_get_length(ctx, -1);
-+	} else {
-+		/* XXX: what to do if _Formals is not empty but compiler has
-+		 * optimized it away -- read length from an explicit property
-+		 * then?
-+		 */
-+	}
-+	duk_pop(ctx);
-+
-+	duk_push_uint(ctx, len_value);  /* [ ... closure template len_value ] */
-+	duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_NONE);
-+
-+	/*
-+	 *  "prototype" is, by default, a fresh object with the "constructor"
-+	 *  property.
-+	 *
-+	 *  Note that this creates a circular reference for every function
-+	 *  instance (closure) which prevents refcount-based collection of
-+	 *  function instances.
-+	 *
-+	 *  XXX: Try to avoid creating the default prototype object, because
-+	 *  many functions are not used as constructors and the default
-+	 *  prototype is unnecessary.  Perhaps it could be created on-demand
-+	 *  when it is first accessed?
-+	 */
-+
-+	/* [ ... closure template ] */
-+
-+	duk_push_object(ctx);  /* -> [ ... closure template newobj ] */
-+	duk_dup(ctx, -3);          /* -> [ ... closure template newobj closure ] */
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC);  /* -> [ ... closure template newobj ] */
-+	duk_compact(ctx, -1);  /* compact the prototype */
-+	duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W);     /* -> [ ... closure template ] */
-+
-+	/*
-+	 *  "arguments" and "caller" must be mapped to throwers for strict
-+	 *  mode and bound functions (E5 Section 15.3.5).
-+	 *
-+	 *  XXX: This is expensive to have for every strict function instance.
-+	 *  Try to implement as virtual properties or on-demand created properties.
-+	 */
-+
-+	/* [ ... closure template ] */
-+
-+	if (DUK_HOBJECT_HAS_STRICT(&fun_clos->obj)) {
-+		duk_xdef_prop_stridx_thrower(ctx, -2, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
-+		duk_xdef_prop_stridx_thrower(ctx, -2, DUK_STRIDX_LC_ARGUMENTS, DUK_PROPDESC_FLAGS_NONE);
-+	} else {
-+#ifdef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+		DUK_DDD(DUK_DDDPRINT("function is non-strict and non-standard 'caller' property in use, add initial 'null' value"));
-+		duk_push_null(ctx);
-+		duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_CALLER, DUK_PROPDESC_FLAGS_NONE);
-+#else
-+		DUK_DDD(DUK_DDDPRINT("function is non-strict and non-standard 'caller' property not used"));
-+#endif
-+	}
-+
-+	/*
-+	 *  "name" is a non-standard property found in at least V8, Rhino, smjs.
-+	 *  For Rhino and smjs it is non-writable, non-enumerable, and non-configurable;
-+	 *  for V8 it is writable, non-enumerable, non-configurable.  It is also defined
-+	 *  for an anonymous function expression in which case the value is an empty string.
-+	 *  We could also leave name 'undefined' for anonymous functions but that would
-+	 *  differ from behavior of other engines, so use an empty string.
-+	 *
-+	 *  XXX: make optional?  costs something per function.
-+	 */
-+
-+	/* [ ... closure template ] */
-+
-+	if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_NAME)) {
-+		/* [ ... closure template name ] */
-+		DUK_ASSERT(duk_is_string(ctx, -1));
-+	} else {
-+		/* [ ... closure template undefined ] */
-+		duk_pop(ctx);
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_EMPTY_STRING);
-+	}
-+	duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_NONE);  /* -> [ ... closure template ] */
-+
-+	/*
-+	 *  Compact the closure, in most cases no properties will be added later.
-+	 *  Also, without this the closures end up having unused property slots
-+	 *  (e.g. in Duktape 0.9.0, 8 slots would be allocated and only 7 used).
-+	 *  A better future solution would be to allocate the closure directly
-+	 *  to correct size (and setup the properties directly without going
-+	 *  through the API).
-+	 */
-+
-+	duk_compact(ctx, -2);
-+
-+	/*
-+	 *  Some assertions (E5 Section 13.2).
-+	 */
-+
-+	DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(&fun_clos->obj) == DUK_HOBJECT_CLASS_FUNCTION);
-+	DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, &fun_clos->obj) == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
-+	DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(&fun_clos->obj));
-+	DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_LENGTH) != 0);
-+	DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_PROTOTYPE) != 0);
-+	DUK_ASSERT(duk_has_prop_stridx(ctx, -2, DUK_STRIDX_NAME) != 0);  /* non-standard */
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(&fun_clos->obj) ||
-+	           duk_has_prop_stridx(ctx, -2, DUK_STRIDX_CALLER) != 0);
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_STRICT(&fun_clos->obj) ||
-+	           duk_has_prop_stridx(ctx, -2, DUK_STRIDX_LC_ARGUMENTS) != 0);
-+
-+	/*
-+	 *  Finish
-+	 */
-+
-+	/* [ ... closure template ] */
-+
-+	DUK_DDD(DUK_DDDPRINT("created function instance: template=%!iT -> closure=%!iT",
-+	                     (duk_tval *) duk_get_tval(ctx, -1),
-+	                     (duk_tval *) duk_get_tval(ctx, -2)));
-+
-+	duk_pop(ctx);
-+
-+	/* [ ... closure ] */
-+}
-+
-+/*
-+ *  Delayed activation environment record initialization (for functions
-+ *  with NEWENV).
-+ *
-+ *  The non-delayed initialization is handled by duk_handle_call().
-+ */
-+
-+/* shared helper */
-+DUK_INTERNAL
-+duk_hobject *duk_create_activation_environment_record(duk_hthread *thr,
-+                                                      duk_hobject *func,
-+                                                      duk_size_t idx_bottom) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *env;
-+	duk_hobject *parent;
-+	duk_tval *tv;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(func != NULL);
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr));
-+	if (tv) {
-+		DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+		DUK_ASSERT(DUK_HOBJECT_IS_ENV(DUK_TVAL_GET_OBJECT(tv)));
-+		parent = DUK_TVAL_GET_OBJECT(tv);
-+	} else {
-+		parent = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+	}
-+
-+	(void) duk_push_object_helper(ctx,
-+	                              DUK_HOBJECT_FLAG_EXTENSIBLE |
-+	                              DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV),
-+	                              -1);  /* no prototype, updated below */
-+	env = duk_require_hobject(ctx, -1);
-+	DUK_ASSERT(env != NULL);
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, env, parent);  /* parent env is the prototype */
-+
-+	/* open scope information, for compiled functions only */
-+
-+	if (DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-+		duk_push_hthread(ctx, thr);
-+		duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_THREAD);
-+		duk_push_hobject(ctx, func);
-+		duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_CALLEE);
-+		duk_push_size_t(ctx, idx_bottom);
-+		duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INT_REGBASE);
-+	}
-+
-+	return env;
-+}
-+
-+DUK_INTERNAL
-+void duk_js_init_activation_environment_records_delayed(duk_hthread *thr,
-+                                                        duk_activation *act) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *func;
-+	duk_hobject *env;
-+
-+	func = DUK_ACT_GET_FUNC(act);
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_BOUND(func));  /* bound functions are never in act 'func' */
-+
-+	/*
-+	 *  Delayed initialization only occurs for 'NEWENV' functions.
-+	 */
-+
-+	DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func));
-+	DUK_ASSERT(act->lex_env == NULL);
-+	DUK_ASSERT(act->var_env == NULL);
-+
-+	env = duk_create_activation_environment_record(thr, func, act->idx_bottom);
-+	DUK_ASSERT(env != NULL);
-+
-+	DUK_DDD(DUK_DDDPRINT("created delayed fresh env: %!ipO", (duk_heaphdr *) env));
-+#ifdef DUK_USE_DDDPRINT
-+	{
-+		duk_hobject *p = env;
-+		while (p) {
-+			DUK_DDD(DUK_DDDPRINT("  -> %!ipO", (duk_heaphdr *) p));
-+			p = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, p);
-+		}
-+	}
-+#endif
-+
-+	act->lex_env = env;
-+	act->var_env = env;
-+	DUK_HOBJECT_INCREF(thr, env);  /* XXX: incref by count (here 2 times) */
-+	DUK_HOBJECT_INCREF(thr, env);
-+
-+	duk_pop(ctx);
-+}
-+
-+/*
-+ *  Closing environment records.
-+ *
-+ *  The environment record MUST be closed with the thread where its activation
-+ *  is.  In other words (if 'env' is open):
-+ *
-+ *    - 'thr' must match _env.thread
-+ *    - 'func' must match _env.callee
-+ *    - 'regbase' must match _env.regbase
-+ *
-+ *  These are not looked up from the env to minimize code size.
-+ *
-+ *  XXX: should access the own properties directly instead of using the API
-+ */
-+
-+DUK_INTERNAL void duk_js_close_environment_record(duk_hthread *thr, duk_hobject *env, duk_hobject *func, duk_size_t regbase) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_uint_fast32_t i;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(env != NULL);
-+	/* func is NULL for lightfuncs */
-+
-+	if (!DUK_HOBJECT_IS_DECENV(env) || DUK_HOBJECT_HAS_ENVRECCLOSED(env)) {
-+		DUK_DDD(DUK_DDDPRINT("environment record not a declarative record, "
-+		                     "or already closed: %!iO",
-+		                     (duk_heaphdr *) env));
-+		return;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("closing environment record: %!iO, func: %!iO, regbase: %ld",
-+	                     (duk_heaphdr *) env, (duk_heaphdr *) func, (long) regbase));
-+
-+	duk_push_hobject(ctx, env);
-+
-+	/* assertions: env must be closed in the same thread as where it runs */
-+#ifdef DUK_USE_ASSERTIONS
-+	{
-+		/* [... env] */
-+
-+		if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_CALLEE)) {
-+			DUK_ASSERT(duk_is_object(ctx, -1));
-+			DUK_ASSERT(duk_get_hobject(ctx, -1) == (duk_hobject *) func);
-+		}
-+		duk_pop(ctx);
-+
-+		if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_THREAD)) {
-+			DUK_ASSERT(duk_is_object(ctx, -1));
-+			DUK_ASSERT(duk_get_hobject(ctx, -1) == (duk_hobject *) thr);
-+		}
-+		duk_pop(ctx);
-+
-+		if (duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_REGBASE)) {
-+			DUK_ASSERT(duk_is_number(ctx, -1));
-+			DUK_ASSERT(duk_get_number(ctx, -1) == (double) regbase);
-+		}
-+		duk_pop(ctx);
-+
-+		/* [... env] */
-+	}
-+#endif
-+
-+	if (func != NULL && DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-+		duk_hobject *varmap;
-+		duk_hstring *key;
-+		duk_tval *tv;
-+		duk_uint_t regnum;
-+
-+		/* XXX: additional conditions when to close variables? we don't want to do it
-+		 * unless the environment may have "escaped" (referenced in a function closure).
-+		 * With delayed environments, the existence is probably good enough of a check.
-+		 */
-+
-+		/* XXX: any way to detect faster whether something needs to be closed?
-+		 * We now look up _Callee and then skip the rest.
-+		 */
-+
-+		/* Note: we rely on the _Varmap having a bunch of nice properties, like:
-+		 *  - being compacted and unmodified during this process
-+		 *  - not containing an array part
-+		 *  - having correct value types
-+		 */
-+
-+		/* [... env] */
-+
-+		if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_CALLEE)) {
-+			DUK_DDD(DUK_DDDPRINT("env has no callee property, nothing to close; re-delete the control properties just in case"));
-+			duk_pop(ctx);
-+			goto skip_varmap;
-+		}
-+
-+		/* [... env callee] */
-+
-+		if (!duk_get_prop_stridx(ctx, -1, DUK_STRIDX_INT_VARMAP)) {
-+			DUK_DDD(DUK_DDDPRINT("callee has no varmap property, nothing to close; delete the control properties"));
-+			duk_pop_2(ctx);
-+			goto skip_varmap;
-+		}
-+		varmap = duk_require_hobject(ctx, -1);
-+		DUK_ASSERT(varmap != NULL);
-+
-+		DUK_DDD(DUK_DDDPRINT("varmap: %!O", (duk_heaphdr *) varmap));
-+
-+		/* [... env callee varmap] */
-+
-+		DUK_DDD(DUK_DDDPRINT("copying bound register values, %ld bound regs", (long) DUK_HOBJECT_GET_ENEXT(varmap)));
-+
-+		for (i = 0; i < (duk_uint_fast32_t) DUK_HOBJECT_GET_ENEXT(varmap); i++) {
-+			key = DUK_HOBJECT_E_GET_KEY(thr->heap, varmap, i);
-+			DUK_ASSERT(key != NULL);   /* assume keys are compacted */
-+
-+			DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, varmap, i));  /* assume plain values */
-+
-+			tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, varmap, i);
-+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));  /* assume value is a number */
-+			regnum = (duk_uint_t) DUK_TVAL_GET_NUMBER(tv);
-+			DUK_ASSERT_DISABLE(regnum >= 0);  /* unsigned */
-+			DUK_ASSERT(regnum < ((duk_hcompiledfunction *) func)->nregs);  /* regnum is sane */
-+			DUK_ASSERT(thr->valstack + regbase + regnum >= thr->valstack);
-+			DUK_ASSERT(thr->valstack + regbase + regnum < thr->valstack_top);
-+
-+			/* XXX: slightly awkward */
-+			duk_push_hstring(ctx, key);
-+			duk_push_tval(ctx, thr->valstack + regbase + regnum);
-+			DUK_DDD(DUK_DDDPRINT("closing identifier '%s' -> reg %ld, value %!T",
-+			                     (const char *) duk_require_string(ctx, -2),
-+			                     (long) regnum,
-+			                     (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+			/* [... env callee varmap key val] */
-+
-+			/* if property already exists, overwrites silently */
-+			duk_xdef_prop(ctx, -5, DUK_PROPDESC_FLAGS_WE);  /* writable but not deletable */
-+		}
-+
-+		duk_pop_2(ctx);
-+
-+		/* [... env] */
-+	}
-+
-+ skip_varmap:
-+
-+	/* [... env] */
-+
-+	duk_del_prop_stridx(ctx, -1, DUK_STRIDX_INT_CALLEE);
-+	duk_del_prop_stridx(ctx, -1, DUK_STRIDX_INT_THREAD);
-+	duk_del_prop_stridx(ctx, -1, DUK_STRIDX_INT_REGBASE);
-+
-+	duk_pop(ctx);
-+
-+	DUK_HOBJECT_SET_ENVRECCLOSED(env);
-+
-+	DUK_DDD(DUK_DDDPRINT("environment record after being closed: %!O",
-+	                     (duk_heaphdr *) env));
-+}
-+
-+/*
-+ *  GETIDREF: a GetIdentifierReference-like helper.
-+ *
-+ *  Provides a parent traversing lookup and a single level lookup
-+ *  (for HasBinding).
-+ *
-+ *  Instead of returning the value, returns a bunch of values allowing
-+ *  the caller to read, write, or delete the binding.  Value pointers
-+ *  are duk_tval pointers which can be mutated directly as long as
-+ *  refcounts are properly updated.  Note that any operation which may
-+ *  reallocate valstacks or compact objects may invalidate the returned
-+ *  duk_tval (but not object) pointers, so caller must be very careful.
-+ *
-+ *  If starting environment record 'env' is given, 'act' is ignored.
-+ *  However, if 'env' is NULL, the caller may identify, in 'act', an
-+ *  activation which hasn't had its declarative environment initialized
-+ *  yet.  The activation registers are then looked up, and its parent
-+ *  traversed normally.
-+ *
-+ *  The 'out' structure values are only valid if the function returns
-+ *  success (non-zero).
-+ */
-+
-+/* lookup name from an open declarative record's registers */
-+DUK_LOCAL
-+duk_bool_t duk__getid_open_decl_env_regs(duk_hthread *thr,
-+                                         duk_hstring *name,
-+                                         duk_hobject *env,
-+                                         duk__id_lookup_result *out) {
-+	duk_hthread *env_thr;
-+	duk_hobject *env_func;
-+	duk_size_t env_regbase;
-+	duk_hobject *varmap;
-+	duk_tval *tv;
-+	duk_size_t reg_rel;
-+	duk_size_t idx;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(name != NULL);
-+	DUK_ASSERT(env != NULL);
-+	DUK_ASSERT(out != NULL);
-+
-+	DUK_ASSERT(DUK_HOBJECT_IS_DECENV(env));
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_CALLEE(thr));
-+	if (!tv) {
-+		/* env is closed, should be missing _Callee, _Thread, _Regbase */
-+		DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_CALLEE(thr)) == NULL);
-+		DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THREAD(thr)) == NULL);
-+		DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_REGBASE(thr)) == NULL);
-+		return 0;
-+	}
-+
-+	DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+	DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_COMPILEDFUNCTION(DUK_TVAL_GET_OBJECT(tv)));
-+	env_func = DUK_TVAL_GET_OBJECT(tv);
-+	DUK_ASSERT(env_func != NULL);
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env_func, DUK_HTHREAD_STRING_INT_VARMAP(thr));
-+	if (!tv) {
-+		return 0;
-+	}
-+	DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+	varmap = DUK_TVAL_GET_OBJECT(tv);
-+	DUK_ASSERT(varmap != NULL);
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, varmap, name);
-+	if (!tv) {
-+		return 0;
-+	}
-+	DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+	reg_rel = (duk_size_t) DUK_TVAL_GET_NUMBER(tv);
-+	DUK_ASSERT_DISABLE(reg_rel >= 0);  /* unsigned */
-+	DUK_ASSERT(reg_rel < ((duk_hcompiledfunction *) env_func)->nregs);
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THREAD(thr));
-+	DUK_ASSERT(tv != NULL);
-+	DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+	DUK_ASSERT(DUK_TVAL_GET_OBJECT(tv) != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_THREAD(DUK_TVAL_GET_OBJECT(tv)));
-+	env_thr = (duk_hthread *) DUK_TVAL_GET_OBJECT(tv);
-+	DUK_ASSERT(env_thr != NULL);
-+
-+	/* Note: env_thr != thr is quite possible and normal, so careful
-+	 * with what thread is used for valstack lookup.
-+	 */
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_REGBASE(thr));
-+	DUK_ASSERT(tv != NULL);
-+	DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+	env_regbase = (duk_size_t) DUK_TVAL_GET_NUMBER(tv);
-+
-+	idx = env_regbase + reg_rel;
-+	tv = env_thr->valstack + idx;
-+	DUK_ASSERT(tv >= env_thr->valstack && tv < env_thr->valstack_end);  /* XXX: more accurate? */
-+
-+	out->value = tv;
-+	out->attrs = DUK_PROPDESC_FLAGS_W;  /* registers are mutable, non-deletable */
-+	out->this_binding = NULL;  /* implicit this value always undefined for
-+	                            * declarative environment records.
-+	                            */
-+	out->env = env;
-+	out->holder = NULL;
-+
-+	return 1;
-+}
-+
-+/* lookup name from current activation record's functions' registers */
-+DUK_LOCAL
-+duk_bool_t duk__getid_activation_regs(duk_hthread *thr,
-+                                      duk_hstring *name,
-+                                      duk_activation *act,
-+                                      duk__id_lookup_result *out) {
-+	duk_tval *tv;
-+	duk_hobject *func;
-+	duk_hobject *varmap;
-+	duk_size_t reg_rel;
-+	duk_size_t idx;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(name != NULL);
-+	DUK_ASSERT(act != NULL);
-+	DUK_ASSERT(out != NULL);
-+
-+	func = DUK_ACT_GET_FUNC(act);
-+	DUK_ASSERT(func != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func));
-+
-+	if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
-+		return 0;
-+	}
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_VARMAP(thr));
-+	if (!tv) {
-+		return 0;
-+	}
-+	DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+	varmap = DUK_TVAL_GET_OBJECT(tv);
-+	DUK_ASSERT(varmap != NULL);
-+
-+	tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, varmap, name);
-+	if (!tv) {
-+		return 0;
-+	}
-+	DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv));
-+	reg_rel = (duk_size_t) DUK_TVAL_GET_NUMBER(tv);
-+	DUK_ASSERT_DISABLE(reg_rel >= 0);
-+	DUK_ASSERT(reg_rel < ((duk_hcompiledfunction *) func)->nregs);
-+
-+	idx = act->idx_bottom + reg_rel;
-+	DUK_ASSERT(idx >= act->idx_bottom);
-+	tv = thr->valstack + idx;
-+
-+	out->value = tv;
-+	out->attrs = DUK_PROPDESC_FLAGS_W;  /* registers are mutable, non-deletable */
-+	out->this_binding = NULL;  /* implicit this value always undefined for
-+	                            * declarative environment records.
-+	                            */
-+	out->env = NULL;
-+	out->holder = NULL;
-+
-+	return 1;
-+}
-+
-+DUK_LOCAL
-+duk_bool_t duk__get_identifier_reference(duk_hthread *thr,
-+                                         duk_hobject *env,
-+                                         duk_hstring *name,
-+                                         duk_activation *act,
-+                                         duk_bool_t parents,
-+                                         duk__id_lookup_result *out) {
-+	duk_tval *tv;
-+	duk_uint_t sanity;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(env != NULL || act != NULL);
-+	DUK_ASSERT(name != NULL);
-+	DUK_ASSERT(out != NULL);
-+
-+	DUK_ASSERT(!env || DUK_HOBJECT_IS_ENV(env));
-+	DUK_ASSERT(!env || !DUK_HOBJECT_HAS_ARRAY_PART(env));
-+
-+	/*
-+	 *  Conceptually, we look for the identifier binding by starting from
-+	 *  'env' and following to chain of environment records (represented
-+	 *  by the prototype chain).
-+	 *
-+	 *  If 'env' is NULL, the current activation does not yet have an
-+	 *  allocated declarative environment record; this should be treated
-+	 *  exactly as if the environment record existed but had no bindings
-+	 *  other than register bindings.
-+	 *
-+	 *  Note: we assume that with the DUK_HOBJECT_FLAG_NEWENV cleared
-+	 *  the environment will always be initialized immediately; hence
-+	 *  a NULL 'env' should only happen with the flag set.  This is the
-+	 *  case for: (1) function calls, and (2) strict, direct eval calls.
-+	 */
-+
-+	if (env == NULL && act != NULL) {
-+		duk_hobject *func;
-+
-+		DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference: env is NULL, activation is non-NULL -> "
-+		                     "delayed env case, look up activation regs first"));
-+
-+		/*
-+		 *  Try registers
-+		 */
-+
-+		if (duk__getid_activation_regs(thr, name, act, out)) {
-+			DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
-+			                     "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
-+			                     "(found from register bindings when env=NULL)",
-+			                     (duk_heaphdr *) name, (duk_tval *) out->value,
-+			                     (long) out->attrs, (duk_tval *) out->this_binding,
-+			                     (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
-+			return 1;
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("not found in current activation regs"));
-+
-+		/*
-+		 *  Not found in registers, proceed to the parent record.
-+		 *  Here we need to determine what the parent would be,
-+		 *  if 'env' was not NULL (i.e. same logic as when initializing
-+		 *  the record).
-+		 *
-+		 *  Note that environment initialization is only deferred when
-+		 *  DUK_HOBJECT_HAS_NEWENV is set, and this only happens for:
-+		 *    - Function code
-+		 *    - Strict eval code
-+		 *
-+		 *  We only need to check _Lexenv here; _Varenv exists only if it
-+		 *  differs from _Lexenv (and thus _Lexenv will also be present).
-+		 */
-+
-+		if (!parents) {
-+			DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference failed, no parent traversal "
-+			                     "(not found from register bindings when env=NULL)"));
-+			goto fail_not_found;
-+		}
-+
-+		func = DUK_ACT_GET_FUNC(act);
-+		DUK_ASSERT(func != NULL);
-+		DUK_ASSERT(DUK_HOBJECT_HAS_NEWENV(func));
-+
-+		tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_LEXENV(thr));
-+		if (tv) {
-+			DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+			env = DUK_TVAL_GET_OBJECT(tv);
-+		} else {
-+			DUK_ASSERT(duk_hobject_find_existing_entry_tval_ptr(thr->heap, func, DUK_HTHREAD_STRING_INT_VARENV(thr)) == NULL);
-+			env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
-+		}
-+
-+		DUK_DDD(DUK_DDDPRINT("continue lookup from env: %!iO",
-+		                     (duk_heaphdr *) env));
-+	}
-+
-+	/*
-+	 *  Prototype walking starting from 'env'.
-+	 *
-+	 *  ('act' is not needed anywhere here.)
-+	 */
-+
-+	sanity = DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY;
-+	while (env != NULL) {
-+		duk_small_int_t cl;
-+		duk_int_t attrs;
-+
-+		DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference, name=%!O, considering env=%p -> %!iO",
-+		                     (duk_heaphdr *) name,
-+		                     (void *) env,
-+		                     (duk_heaphdr *) env));
-+
-+		DUK_ASSERT(env != NULL);
-+		DUK_ASSERT(DUK_HOBJECT_IS_ENV(env));
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(env));
-+
-+		cl = DUK_HOBJECT_GET_CLASS_NUMBER(env);
-+		DUK_ASSERT(cl == DUK_HOBJECT_CLASS_OBJENV || cl == DUK_HOBJECT_CLASS_DECENV);
-+		if (cl == DUK_HOBJECT_CLASS_DECENV) {
-+			/*
-+			 *  Declarative environment record.
-+			 *
-+			 *  Identifiers can never be stored in ancestors and are
-+			 *  always plain values, so we can use an internal helper
-+			 *  and access the value directly with an duk_tval ptr.
-+			 *
-+			 *  A closed environment is only indicated by it missing
-+			 *  the "book-keeping" properties required for accessing
-+			 *  register-bound variables.
-+			 */
-+
-+			if (DUK_HOBJECT_HAS_ENVRECCLOSED(env)) {
-+				/* already closed */
-+				goto skip_regs;
-+			}
-+
-+			if (duk__getid_open_decl_env_regs(thr, name, env, out)) {
-+				DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
-+				                     "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
-+				                     "(declarative environment record, scope open, found in regs)",
-+				                     (duk_heaphdr *) name, (duk_tval *) out->value,
-+				                     (long) out->attrs, (duk_tval *) out->this_binding,
-+				                     (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
-+				return 1;
-+			}
-+		 skip_regs:
-+
-+			tv = duk_hobject_find_existing_entry_tval_ptr_and_attrs(thr->heap, env, name, &attrs);
-+			if (tv) {
-+				out->value = tv;
-+				out->attrs = attrs;
-+				out->this_binding = NULL;  /* implicit this value always undefined for
-+				                            * declarative environment records.
-+				                            */
-+				out->env = env;
-+				out->holder = env;
-+
-+				DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
-+				                     "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
-+				                     "(declarative environment record, found in properties)",
-+				                     (duk_heaphdr *) name, (duk_tval *) out->value,
-+				                     (long) out->attrs, (duk_tval *) out->this_binding,
-+				                     (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
-+				return 1;
-+			}
-+		} else {
-+			/*
-+			 *  Object environment record.
-+			 *
-+			 *  Binding (target) object is an external, uncontrolled object.
-+			 *  Identifier may be bound in an ancestor property, and may be
-+			 *  an accessor.
-+			 */
-+
-+			/* XXX: we could save space by using _Target OR _This.  If _Target, assume
-+			 * this binding is undefined.  If _This, assumes this binding is _This, and
-+			 * target is also _This.  One property would then be enough.
-+			 */
-+
-+			duk_hobject *target;
-+
-+			DUK_ASSERT(cl == DUK_HOBJECT_CLASS_OBJENV);
-+
-+			tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_TARGET(thr));
-+			DUK_ASSERT(tv != NULL);
-+			DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+			target = DUK_TVAL_GET_OBJECT(tv);
-+			DUK_ASSERT(target != NULL);
-+
-+			/* Note: we must traverse the prototype chain, so use an actual
-+			 * hasprop call here.  The property may also be an accessor, so
-+			 * we can't get an duk_tval pointer here.
-+			 *
-+			 * out->holder is NOT set to the actual duk_hobject where the
-+			 * property is found, but rather the target object.
-+			 */
-+
-+			if (duk_hobject_hasprop_raw(thr, target, name)) {
-+				out->value = NULL;  /* can't get value, may be accessor */
-+				out->attrs = 0;     /* irrelevant when out->value == NULL */
-+				tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_THIS(thr));
-+				out->this_binding = tv;  /* may be NULL */
-+				out->env = env;
-+				out->holder = target;
-+
-+				DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference successful: "
-+				                     "name=%!O -> value=%!T, attrs=%ld, this=%!T, env=%!O, holder=%!O "
-+				                     "(object environment record)",
-+				                     (duk_heaphdr *) name, (duk_tval *) out->value,
-+				                     (long) out->attrs, (duk_tval *) out->this_binding,
-+				                     (duk_heaphdr *) out->env, (duk_heaphdr *) out->holder));
-+				return 1;
-+			}
-+		}
-+
-+		if (!parents) {
-+			DUK_DDD(DUK_DDDPRINT("duk__get_identifier_reference failed, no parent traversal "
-+			                     "(not found from first traversed env)"));
-+			goto fail_not_found;
-+		}
-+
-+                if (sanity-- == 0) {
-+                        DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_PROTOTYPE_CHAIN_LIMIT);
-+                }
-+		env = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, env);
-+	};
-+
-+	/*
-+	 *  Not found (even in global object)
-+	 */
-+
-+ fail_not_found:
-+	return 0;
-+}
-+
-+/*
-+ *  HASVAR: check identifier binding from a given environment record
-+ *  without traversing its parents.
-+ *
-+ *  This primitive is not exposed to user code as such, but is used
-+ *  internally for e.g. declaration binding instantiation.
-+ *
-+ *  See E5 Sections:
-+ *    10.2.1.1.1 HasBinding(N)
-+ *    10.2.1.2.1 HasBinding(N)
-+ *
-+ *  Note: strictness has no bearing on this check.  Hence we don't take
-+ *  a 'strict' parameter.
-+ */
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL
-+duk_bool_t duk_js_hasvar_envrec(duk_hthread *thr,
-+                                duk_hobject *env,
-+                                duk_hstring *name) {
-+	duk__id_lookup_result ref;
-+	duk_bool_t parents;
-+
-+	DUK_DDD(DUK_DDDPRINT("hasvar: thr=%p, env=%p, name=%!O "
-+	                     "(env -> %!dO)",
-+	                     (void *) thr, (void *) env, (duk_heaphdr *) name,
-+	                     (duk_heaphdr *) env));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(env != NULL);
-+	DUK_ASSERT(name != NULL);
-+
-+        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env);
-+        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name);
-+
-+	DUK_ASSERT(DUK_HOBJECT_IS_ENV(env));
-+	DUK_ASSERT(!DUK_HOBJECT_HAS_ARRAY_PART(env));
-+
-+	/* lookup results is ignored */
-+	parents = 0;
-+	return duk__get_identifier_reference(thr, env, name, NULL, parents, &ref);
-+}
-+#endif
-+
-+/*
-+ *  GETVAR
-+ *
-+ *  See E5 Sections:
-+ *    11.1.2 Identifier Reference
-+ *    10.3.1 Identifier Resolution
-+ *    11.13.1 Simple Assignment  [example of where the Reference is GetValue'd]
-+ *    8.7.1 GetValue (V)
-+ *    8.12.1 [[GetOwnProperty]] (P)
-+ *    8.12.2 [[GetProperty]] (P)
-+ *    8.12.3 [[Get]] (P)
-+ *
-+ *  If 'throw' is true, always leaves two values on top of stack: [val this].
-+ *
-+ *  If 'throw' is false, returns 0 if identifier cannot be resolved, and the
-+ *  stack will be unaffected in this case.  If identifier is resolved, returns
-+ *  1 and leaves [val this] on top of stack.
-+ *
-+ *  Note: the 'strict' flag of a reference returned by GetIdentifierReference
-+ *  is ignored by GetValue.  Hence we don't take a 'strict' parameter.
-+ *
-+ *  The 'throw' flag is needed for implementing 'typeof' for an unreferenced
-+ *  identifier.  An unreference identifier in other contexts generates a
-+ *  ReferenceError.
-+ */
-+
-+DUK_LOCAL
-+duk_bool_t duk__getvar_helper(duk_hthread *thr,
-+                              duk_hobject *env,
-+                              duk_activation *act,
-+                              duk_hstring *name,
-+                              duk_bool_t throw_flag) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk__id_lookup_result ref;
-+	duk_tval tv_tmp_obj;
-+	duk_tval tv_tmp_key;
-+	duk_bool_t parents;
-+
-+	DUK_DDD(DUK_DDDPRINT("getvar: thr=%p, env=%p, act=%p, name=%!O "
-+	                     "(env -> %!dO)",
-+	                     (void *) thr, (void *) env, (void *) act,
-+	                     (duk_heaphdr *) name, (duk_heaphdr *) env));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(name != NULL);
-+	/* env and act may be NULL */
-+
-+        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env);
-+        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name);
-+
-+	parents = 1;     /* follow parent chain */
-+	if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
-+		if (ref.value) {
-+			DUK_ASSERT(ref.this_binding == NULL);  /* always for register bindings */
-+			duk_push_tval(ctx, ref.value);
-+			duk_push_undefined(ctx);
-+		} else {
-+			DUK_ASSERT(ref.holder != NULL);
-+
-+			/* Note: getprop may invoke any getter and invalidate any
-+			 * duk_tval pointers, so this must be done first.
-+			 */
-+
-+			if (ref.this_binding) {
-+				duk_push_tval(ctx, ref.this_binding);
-+			} else {
-+				duk_push_undefined(ctx);
-+			}
-+
-+			DUK_TVAL_SET_OBJECT(&tv_tmp_obj, ref.holder);
-+			DUK_TVAL_SET_STRING(&tv_tmp_key, name);
-+			(void) duk_hobject_getprop(thr, &tv_tmp_obj, &tv_tmp_key);  /* [this value] */
-+
-+			/* ref.value, ref.this.binding invalidated here by getprop call */
-+
-+			duk_insert(ctx, -2);  /* [this value] -> [value this] */
-+		}
-+
-+		return 1;
-+	} else {
-+		if (throw_flag) {
-+			DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR,
-+			          "identifier '%s' undefined",
-+			          (const char *) DUK_HSTRING_GET_DATA(name));
-+		}
-+
-+		return 0;
-+	}
-+}
-+
-+DUK_INTERNAL
-+duk_bool_t duk_js_getvar_envrec(duk_hthread *thr,
-+                                duk_hobject *env,
-+                                duk_hstring *name,
-+                                duk_bool_t throw_flag) {
-+	return duk__getvar_helper(thr, env, NULL, name, throw_flag);
-+}
-+
-+DUK_INTERNAL
-+duk_bool_t duk_js_getvar_activation(duk_hthread *thr,
-+                                    duk_activation *act,
-+                                    duk_hstring *name,
-+                                    duk_bool_t throw_flag) {
-+	DUK_ASSERT(act != NULL);
-+	return duk__getvar_helper(thr, act->lex_env, act, name, throw_flag);
-+}
-+
-+/*
-+ *  PUTVAR
-+ *
-+ *  See E5 Sections:
-+ *    11.1.2 Identifier Reference
-+ *    10.3.1 Identifier Resolution
-+ *    11.13.1 Simple Assignment  [example of where the Reference is PutValue'd]
-+ *    8.7.2 PutValue (V,W)  [see especially step 3.b, undefined -> automatic global in non-strict mode]
-+ *    8.12.4 [[CanPut]] (P)
-+ *    8.12.5 [[Put]] (P)
-+ *
-+ *  Note: may invalidate any valstack (or object) duk_tval pointers because
-+ *  putting a value may reallocate any object or any valstack.  Caller beware.
-+ */
-+
-+DUK_LOCAL
-+void duk__putvar_helper(duk_hthread *thr,
-+                        duk_hobject *env,
-+                        duk_activation *act,
-+                        duk_hstring *name,
-+                        duk_tval *val,
-+                        duk_bool_t strict) {
-+	duk__id_lookup_result ref;
-+	duk_tval tv_tmp_obj;
-+	duk_tval tv_tmp_key;
-+	duk_bool_t parents;
-+
-+	DUK_DDD(DUK_DDDPRINT("putvar: thr=%p, env=%p, act=%p, name=%!O, val=%p, strict=%ld "
-+	                     "(env -> %!dO, val -> %!T)",
-+	                     (void *) thr, (void *) env, (void *) act,
-+	                     (duk_heaphdr *) name, (void *) val, (long) strict,
-+	                     (duk_heaphdr *) env, (duk_tval *) val));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(name != NULL);
-+	DUK_ASSERT(val != NULL);
-+	/* env and act may be NULL */
-+
-+        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(env);
-+        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name);
-+	DUK_ASSERT_REFCOUNT_NONZERO_TVAL(val);
-+
-+	/*
-+	 *  In strict mode E5 protects 'eval' and 'arguments' from being
-+	 *  assigned to (or even declared anywhere).  Attempt to do so
-+	 *  should result in a compile time SyntaxError.  See the internal
-+	 *  design documentation for details.
-+	 *
-+	 *  Thus, we should never come here, run-time, for strict code,
-+	 *  and name 'eval' or 'arguments'.
-+	 */
-+
-+	DUK_ASSERT(!strict ||
-+	           (name != DUK_HTHREAD_STRING_EVAL(thr) &&
-+	            name != DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)));
-+
-+	/*
-+	 *  Lookup variable and update in-place if found.
-+	 */
-+
-+	parents = 1;     /* follow parent chain */
-+
-+	if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
-+		if (ref.value && (ref.attrs & DUK_PROPDESC_FLAG_WRITABLE)) {
-+			/* Update duk_tval in-place if pointer provided and the
-+			 * property is writable.  If the property is not writable
-+			 * (immutable binding), use duk_hobject_putprop() which
-+			 * will respect mutability.
-+			 */
-+			duk_tval tv_tmp;
-+			duk_tval *tv_val;
-+
-+			DUK_ASSERT(ref.this_binding == NULL);  /* always for register bindings */
-+
-+			tv_val = ref.value;
-+			DUK_ASSERT(tv_val != NULL);
-+			DUK_TVAL_SET_TVAL(&tv_tmp, tv_val);
-+			DUK_TVAL_SET_TVAL(tv_val, val);
-+			DUK_TVAL_INCREF(thr, val);
-+			DUK_TVAL_DECREF(thr, &tv_tmp);  /* must be last */
-+
-+			/* ref.value and ref.this_binding invalidated here */
-+		} else {
-+			DUK_ASSERT(ref.holder != NULL);
-+
-+			DUK_TVAL_SET_OBJECT(&tv_tmp_obj, ref.holder);
-+			DUK_TVAL_SET_STRING(&tv_tmp_key, name);
-+			(void) duk_hobject_putprop(thr, &tv_tmp_obj, &tv_tmp_key, val, strict);
-+
-+			/* ref.value and ref.this_binding invalidated here */
-+		}
-+
-+		return;
-+	}
-+
-+	/*
-+	 *  Not found: write to global object (non-strict) or ReferenceError
-+	 *  (strict); see E5 Section 8.7.2, step 3.
-+	 */
-+
-+	if (strict) {
-+		DUK_DDD(DUK_DDDPRINT("identifier binding not found, strict => reference error"));
-+		DUK_ERROR(thr, DUK_ERR_REFERENCE_ERROR, "identifier not defined");
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("identifier binding not found, not strict => set to global"));
-+
-+	DUK_TVAL_SET_OBJECT(&tv_tmp_obj, thr->builtins[DUK_BIDX_GLOBAL]);
-+	DUK_TVAL_SET_STRING(&tv_tmp_key, name);
-+	(void) duk_hobject_putprop(thr, &tv_tmp_obj, &tv_tmp_key, val, 0);  /* 0 = no throw */
-+
-+	/* NB: 'val' may be invalidated here because put_value may realloc valstack,
-+	 * caller beware.
-+	 */
-+}
-+
-+DUK_INTERNAL
-+void duk_js_putvar_envrec(duk_hthread *thr,
-+                          duk_hobject *env,
-+                          duk_hstring *name,
-+                          duk_tval *val,
-+                          duk_bool_t strict) {
-+	duk__putvar_helper(thr, env, NULL, name, val, strict);
-+}
-+
-+DUK_INTERNAL
-+void duk_js_putvar_activation(duk_hthread *thr,
-+                              duk_activation *act,
-+                              duk_hstring *name,
-+                              duk_tval *val,
-+                              duk_bool_t strict) {
-+	DUK_ASSERT(act != NULL);
-+	duk__putvar_helper(thr, act->lex_env, act, name, val, strict);
-+}
-+
-+/*
-+ *  DELVAR
-+ *
-+ *  See E5 Sections:
-+ *    11.4.1 The delete operator
-+ *    10.2.1.1.5 DeleteBinding (N)  [declarative environment record]
-+ *    10.2.1.2.5 DeleteBinding (N)  [object environment record]
-+ *
-+ *  Variable bindings established inside eval() are deletable (configurable),
-+ *  other bindings are not, including variables declared in global level.
-+ *  Registers are always non-deletable, and the deletion of other bindings
-+ *  is controlled by the configurable flag.
-+ *
-+ *  For strict mode code, the 'delete' operator should fail with a compile
-+ *  time SyntaxError if applied to identifiers.  Hence, no strict mode
-+ *  run-time deletion of identifiers should ever happen.  This function
-+ *  should never be called from strict mode code!
-+ */
-+
-+DUK_LOCAL
-+duk_bool_t duk__delvar_helper(duk_hthread *thr,
-+                              duk_hobject *env,
-+                              duk_activation *act,
-+                              duk_hstring *name) {
-+	duk__id_lookup_result ref;
-+	duk_bool_t parents;
-+
-+	DUK_DDD(DUK_DDDPRINT("delvar: thr=%p, env=%p, act=%p, name=%!O "
-+	                     "(env -> %!dO)",
-+	                     (void *) thr, (void *) env, (void *) act,
-+	                     (duk_heaphdr *) name, (duk_heaphdr *) env));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(name != NULL);
-+	/* env and act may be NULL */
-+
-+        DUK_ASSERT_REFCOUNT_NONZERO_HEAPHDR(name);
-+
-+	parents = 1;     /* follow parent chain */
-+
-+	if (duk__get_identifier_reference(thr, env, name, act, parents, &ref)) {
-+		if (ref.value && !(ref.attrs & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
-+			/* Identifier found in registers (always non-deletable)
-+			 * or declarative environment record and non-configurable.
-+			 */
-+			return 0;
-+		}
-+		DUK_ASSERT(ref.holder != NULL);
-+
-+		return duk_hobject_delprop_raw(thr, ref.holder, name, 0);
-+	}
-+
-+	/*
-+	 *  Not found (even in global object).
-+	 *
-+	 *  In non-strict mode this is a silent SUCCESS (!), see E5 Section 11.4.1,
-+	 *  step 3.b.  In strict mode this case is a compile time SyntaxError so
-+	 *  we should not come here.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("identifier to be deleted not found: name=%!O "
-+	                     "(treated as silent success)",
-+	                     (duk_heaphdr *) name));
-+	return 1;
-+}
-+
-+#if 0  /*unused*/
-+DUK_INTERNAL
-+duk_bool_t duk_js_delvar_envrec(duk_hthread *thr,
-+                                duk_hobject *env,
-+                                duk_hstring *name) {
-+	return duk__delvar_helper(thr, env, NULL, name);
-+}
-+#endif
-+
-+DUK_INTERNAL
-+duk_bool_t duk_js_delvar_activation(duk_hthread *thr,
-+                                    duk_activation *act,
-+                                    duk_hstring *name) {
-+	DUK_ASSERT(act != NULL);
-+	return duk__delvar_helper(thr, act->lex_env, act, name);
-+}
-+
-+/*
-+ *  DECLVAR
-+ *
-+ *  See E5 Sections:
-+ *    10.4.3 Entering Function Code
-+ *    10.5 Declaration Binding Instantion
-+ *    12.2 Variable Statement
-+ *    11.1.2 Identifier Reference
-+ *    10.3.1 Identifier Resolution
-+ *
-+ *  Variable declaration behavior is mainly discussed in Section 10.5,
-+ *  and is not discussed in the execution semantics (Sections 11-13).
-+ *
-+ *  Conceptually declarations happen when code (global, eval, function)
-+ *  is entered, before any user code is executed.  In practice, register-
-+ *  bound identifiers are 'declared' automatically (by virtue of being
-+ *  allocated to registers with the initial value 'undefined').  Other
-+ *  identifiers are declared in the function prologue with this primitive.
-+ *
-+ *  Since non-register bindings eventually back to an internal object's
-+ *  properties, the 'prop_flags' argument is used to specify binding
-+ *  type:
-+ *
-+ *    - Immutable binding: set DUK_PROPDESC_FLAG_WRITABLE to false
-+ *    - Non-deletable binding: set DUK_PROPDESC_FLAG_CONFIGURABLE to false
-+ *    - The flag DUK_PROPDESC_FLAG_ENUMERABLE should be set, although it
-+ *      doesn't really matter for internal objects
-+ *
-+ *  All bindings are non-deletable mutable bindings except:
-+ *
-+ *    - Declarations in eval code (mutable, deletable)
-+ *    - 'arguments' binding in strict function code (immutable)
-+ *    - Function name binding of a function expression (immutable)
-+ *
-+ *  Declarations may go to declarative environment records (always
-+ *  so for functions), but may also go to object environment records
-+ *  (e.g. global code).  The global object environment has special
-+ *  behavior when re-declaring a function (but not a variable); see
-+ *  E5.1 specification, Section 10.5, step 5.e.
-+ *
-+ *  Declarations always go to the 'top-most' environment record, i.e.
-+ *  we never check the record chain.  It's not an error even if a
-+ *  property (even an immutable or non-deletable one) of the same name
-+ *  already exists.
-+ *
-+ *  If a declared variable already exists, its value needs to be updated
-+ *  (if possible).  Returns 1 if a PUTVAR needs to be done by the caller;
-+ *  otherwise returns 0.
-+ */
-+
-+DUK_LOCAL
-+duk_bool_t duk__declvar_helper(duk_hthread *thr,
-+                               duk_hobject *env,
-+                               duk_hstring *name,
-+                               duk_tval *val,
-+                               duk_small_int_t prop_flags,
-+                               duk_bool_t is_func_decl) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *holder;
-+	duk_bool_t parents;
-+	duk__id_lookup_result ref;
-+	duk_tval *tv;
-+
-+	DUK_DDD(DUK_DDDPRINT("declvar: thr=%p, env=%p, name=%!O, val=%!T, prop_flags=0x%08lx, is_func_decl=%ld "
-+	                     "(env -> %!iO)",
-+	                     (void *) thr, (void *) env, (duk_heaphdr *) name,
-+	                     (duk_tval *) val, (unsigned long) prop_flags,
-+	                     (unsigned int) is_func_decl, (duk_heaphdr *) env));
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(env != NULL);
-+	DUK_ASSERT(name != NULL);
-+	DUK_ASSERT(val != NULL);
-+
-+	/* Note: in strict mode the compiler should reject explicit
-+	 * declaration of 'eval' or 'arguments'.  However, internal
-+	 * bytecode may declare 'arguments' in the function prologue.
-+	 * We don't bother checking (or asserting) for these now.
-+	 */
-+
-+	/* Note: val is a stable duk_tval pointer.  The caller makes
-+	 * a value copy into its stack frame, so 'tv_val' is not subject
-+	 * to side effects here.
-+	 */
-+
-+	/*
-+	 *  Check whether already declared.
-+	 *
-+	 *  We need to check whether the binding exists in the environment
-+	 *  without walking its parents.  However, we still need to check
-+	 *  register-bound identifiers and the prototype chain of an object
-+	 *  environment target object.
-+	 */
-+
-+	parents = 0;  /* just check 'env' */
-+	if (duk__get_identifier_reference(thr, env, name, NULL, parents, &ref)) {
-+		duk_int_t e_idx;
-+		duk_int_t h_idx;
-+		duk_small_int_t flags;
-+
-+		/*
-+		 *  Variable already declared, ignore re-declaration.
-+		 *  The only exception is the updated behavior of E5.1 for
-+		 *  global function declarations, E5.1 Section 10.5, step 5.e.
-+		 *  This behavior does not apply to global variable declarations.
-+		 */
-+
-+		if (!(is_func_decl && env == thr->builtins[DUK_BIDX_GLOBAL_ENV])) {
-+			DUK_DDD(DUK_DDDPRINT("re-declare a binding, ignoring"));
-+			return 1;  /* 1 -> needs a PUTVAR */
-+		}
-+
-+		/*
-+		 *  Special behavior in E5.1.
-+		 *
-+		 *  Note that even though parents == 0, the conflicting property
-+		 *  may be an inherited property (currently our global object's
-+		 *  prototype is Object.prototype).  Step 5.e first operates on
-+		 *  the existing property (which is potentially in an ancestor)
-+		 *  and then defines a new property in the global object (and
-+		 *  never modifies the ancestor).
-+		 *
-+		 *  Also note that this logic would become even more complicated
-+		 *  if the conflicting property might be a virtual one.  Object
-+		 *  prototype has no virtual properties, though.
-+		 *
-+		 *  XXX: this is now very awkward, rework.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("re-declare a function binding in global object, "
-+		                     "updated E5.1 processing"));
-+
-+		DUK_ASSERT(ref.holder != NULL);
-+		holder = ref.holder;
-+
-+		/* holder will be set to the target object, not the actual object
-+		 * where the property was found (see duk__get_identifier_reference()).
-+		 */
-+		DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(holder) == DUK_HOBJECT_CLASS_GLOBAL);
-+		DUK_ASSERT(!DUK_HOBJECT_HAS_EXOTIC_ARRAY(holder));  /* global object doesn't have array part */
-+
-+		/* XXX: use a helper for prototype traversal; no loop check here */
-+		/* must be found: was found earlier, and cannot be inherited */
-+		for (;;) {
-+			DUK_ASSERT(holder != NULL);
-+			duk_hobject_find_existing_entry(thr->heap, holder, name, &e_idx, &h_idx);
-+			if (e_idx >= 0) {
-+				break;
-+			}
-+			/* SCANBUILD: NULL pointer dereference, doesn't actually trigger,
-+			 * asserted above.
-+			 */
-+			holder = DUK_HOBJECT_GET_PROTOTYPE(thr->heap, holder);
-+		}
-+		DUK_ASSERT(holder != NULL);
-+		DUK_ASSERT(e_idx >= 0);
-+		/* SCANBUILD: scan-build produces a NULL pointer dereference warning
-+		 * below; it never actually triggers because holder is actually never
-+		 * NULL.
-+		 */
-+
-+		/* ref.holder is global object, holder is the object with the
-+		 * conflicting property.
-+		 */
-+
-+		flags = DUK_HOBJECT_E_GET_FLAGS(thr->heap, holder, e_idx);
-+		if (!(flags & DUK_PROPDESC_FLAG_CONFIGURABLE)) {
-+			if (flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+				DUK_DDD(DUK_DDDPRINT("existing property is a non-configurable "
-+				                     "accessor -> reject"));
-+				goto fail_existing_attributes;
-+			}
-+			if (!((flags & DUK_PROPDESC_FLAG_WRITABLE) &&
-+			      (flags & DUK_PROPDESC_FLAG_ENUMERABLE))) {
-+				DUK_DDD(DUK_DDDPRINT("existing property is a non-configurable "
-+				                     "plain property which is not writable and "
-+				                     "enumerable -> reject"));
-+				goto fail_existing_attributes;
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("existing property is not configurable but "
-+			                     "is plain, enumerable, and writable -> "
-+			                     "allow redeclaration"));
-+		}
-+
-+		if (holder == ref.holder) {
-+			/* XXX: if duk_hobject_define_property_internal() was updated
-+			 * to handle a pre-existing accessor property, this would be
-+			 * a simple call (like for the ancestor case).
-+			 */
-+			DUK_DDD(DUK_DDDPRINT("redefine, offending property in global object itself"));
-+
-+			if (flags & DUK_PROPDESC_FLAG_ACCESSOR) {
-+				duk_hobject *tmp;
-+
-+				tmp = DUK_HOBJECT_E_GET_VALUE_GETTER(thr->heap, holder, e_idx);
-+				DUK_HOBJECT_E_SET_VALUE_GETTER(thr->heap, holder, e_idx, NULL);
-+				DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+				DUK_UNREF(tmp);
-+				tmp = DUK_HOBJECT_E_GET_VALUE_SETTER(thr->heap, holder, e_idx);
-+				DUK_HOBJECT_E_SET_VALUE_SETTER(thr->heap, holder, e_idx, NULL);
-+				DUK_HOBJECT_DECREF_ALLOWNULL(thr, tmp);
-+				DUK_UNREF(tmp);
-+			} else {
-+				duk_tval tv_tmp;
-+
-+				tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx);
-+				DUK_TVAL_SET_TVAL(&tv_tmp, tv);
-+				DUK_TVAL_SET_UNDEFINED_UNUSED(tv);
-+				DUK_TVAL_DECREF(thr, &tv_tmp);
-+			}
-+
-+			/* Here val would be potentially invalid if we didn't make
-+			 * a value copy at the caller.
-+			 */
-+
-+			tv = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx);
-+			DUK_TVAL_SET_TVAL(tv, val);
-+			DUK_TVAL_INCREF(thr, tv);
-+			DUK_HOBJECT_E_SET_FLAGS(thr->heap, holder, e_idx, prop_flags);
-+
-+			DUK_DDD(DUK_DDDPRINT("updated global binding, final result: "
-+			                     "value -> %!T, prop_flags=0x%08lx",
-+			                     (duk_tval *) DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, holder, e_idx),
-+			                     (unsigned long) prop_flags));
-+		} else {
-+			DUK_DDD(DUK_DDDPRINT("redefine, offending property in ancestor"));
-+
-+			DUK_ASSERT(ref.holder == thr->builtins[DUK_BIDX_GLOBAL]);
-+			duk_push_tval(ctx, val);
-+			duk_hobject_define_property_internal(thr, ref.holder, name, prop_flags);
-+		}
-+
-+		return 0;
-+	}
-+
-+	/*
-+	 *  Not found (in registers or record objects).  Declare
-+	 *  to current variable environment.
-+	 */
-+
-+	/*
-+	 *  Get holder object
-+	 */
-+
-+	if (DUK_HOBJECT_IS_DECENV(env)) {
-+		holder = env;
-+	} else {
-+		DUK_ASSERT(DUK_HOBJECT_IS_OBJENV(env));
-+
-+		tv = duk_hobject_find_existing_entry_tval_ptr(thr->heap, env, DUK_HTHREAD_STRING_INT_TARGET(thr));
-+		DUK_ASSERT(tv != NULL);
-+		DUK_ASSERT(DUK_TVAL_IS_OBJECT(tv));
-+		holder = DUK_TVAL_GET_OBJECT(tv);
-+		DUK_ASSERT(holder != NULL);
-+	}
-+
-+	/*
-+	 *  Define new property
-+	 *
-+	 *  Note: this may fail if the holder is not extensible.
-+	 */
-+
-+	/* XXX: this is awkward as we use an internal method which doesn't handle
-+	 * extensibility etc correctly.  Basically we'd want to do a [[DefineOwnProperty]]
-+	 * or Object.defineProperty() here.
-+	 */
-+
-+	if (!DUK_HOBJECT_HAS_EXTENSIBLE(holder)) {
-+		goto fail_not_extensible;
-+	}
-+
-+	duk_push_hobject(ctx, holder);
-+	duk_push_hstring(ctx, name);
-+	duk_push_tval(ctx, val);
-+	duk_xdef_prop(ctx, -3, prop_flags);  /* [holder name val] -> [holder] */
-+	duk_pop(ctx);
-+
-+	return 0;
-+
-+ fail_existing_attributes:
-+ fail_not_extensible:
-+	DUK_ERROR(thr, DUK_ERR_TYPE_ERROR, "declaration failed");
-+	return 0;
-+}
-+
-+DUK_INTERNAL
-+duk_bool_t duk_js_declvar_activation(duk_hthread *thr,
-+                                     duk_activation *act,
-+                                     duk_hstring *name,
-+                                     duk_tval *val,
-+                                     duk_small_int_t prop_flags,
-+                                     duk_bool_t is_func_decl) {
-+	duk_hobject *env;
-+	duk_tval tv_val_copy;
-+
-+	/*
-+	 *  Make a value copy of the input val.  This ensures that
-+	 *  side effects cannot invalidate the pointer.
-+	 */
-+
-+	DUK_TVAL_SET_TVAL(&tv_val_copy, val);
-+	val = &tv_val_copy;
-+
-+	/*
-+	 *  Delayed env creation check
-+	 */
-+
-+	if (!act->var_env) {
-+		DUK_ASSERT(act->lex_env == NULL);
-+		duk_js_init_activation_environment_records_delayed(thr, act);
-+	}
-+	DUK_ASSERT(act->lex_env != NULL);
-+	DUK_ASSERT(act->var_env != NULL);
-+
-+	env = act->var_env;
-+	DUK_ASSERT(env != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_IS_ENV(env));
-+
-+	return duk__declvar_helper(thr, env, name, val, prop_flags, is_func_decl);
-+}
-+#line 1 "duk_lexer.c"
-+/*
-+ *  Lexer for source files, ToNumber() string conversions, RegExp expressions,
-+ *  and JSON.
-+ *
-+ *  Provides a stream of Ecmascript tokens from an UTF-8/CESU-8 buffer.  The
-+ *  caller can also rewind the token stream into a certain position which is
-+ *  needed by the compiler part for multi-pass scanning.  Tokens are
-+ *  represented as duk_token structures, and contain line number information.
-+ *  Token types are identified with DUK_TOK_* defines.
-+ *
-+ *  Characters are decoded into a fixed size lookup window consisting of
-+ *  decoded Unicode code points, with window positions past the end of the
-+ *  input filled with an invalid codepoint (-1).  The tokenizer can thus
-+ *  perform multiple character lookups efficiently and with few sanity
-+ *  checks (such as access outside the end of the input), which keeps the
-+ *  tokenization code small at the cost of performance.
-+ *
-+ *  Character data in tokens (such as identifier names and string literals)
-+ *  is encoded into CESU-8 format on-the-fly while parsing the token in
-+ *  question.  The string data is made reachable to garbage collection by
-+ *  placing the token-related values in value stack entries allocated for
-+ *  this purpose by the caller.  The characters exist in Unicode code point
-+ *  form only in the fixed size lookup window, which keeps character data
-+ *  expansion (of especially ASCII data) low.
-+ *
-+ *  Token parsing supports the full range of Unicode characters as described
-+ *  in the E5 specification.  Parsing has been optimized for ASCII characters
-+ *  because ordinary Ecmascript code consists almost entirely of ASCII
-+ *  characters.  Matching of complex Unicode codepoint sets (such as in the
-+ *  IdentifierStart and IdentifierPart productions) is optimized for size,
-+ *  and is done using a linear scan of a bit-packed list of ranges.  This is
-+ *  very slow, but should never be entered unless the source code actually
-+ *  contains Unicode characters.
-+ *
-+ *  Ecmascript tokenization is partially context sensitive.  First,
-+ *  additional future reserved words are recognized in strict mode (see E5
-+ *  Section 7.6.1.2).  Second, a forward slash character ('/') can be
-+ *  recognized either as starting a RegExp literal or as a division operator,
-+ *  depending on context.  The caller must provide necessary context flags
-+ *  when requesting a new token.
-+ *
-+ *  Future work:
-+ *
-+ *    * Make the input window a circular array to avoid copying.  This would
-+ *      not necessarily complicate the tokenizer much, although it would make
-+ *      the window fetches more expensive (one AND).
-+ *
-+ *    * Make line number tracking optional, as it consumes space.  Also, is
-+ *      tracking end line really useful for tokens?
-+ *
-+ *    * Add a feature flag for disabling UTF-8 decoding of input, as most
-+ *      source code is ASCII.  Because of Unicode escapes written in ASCII,
-+ *      this does not allow Unicode support to be removed from e.g.
-+ *      duk_unicode_is_identifier_start() nor does it allow removal of CESU-8
-+ *      encoding of e.g. string literals.
-+ *
-+ *    * Add a feature flag for disabling Unicode compliance of e.g. identifier
-+ *      names.  This allows for a build more than a kilobyte smaller, because
-+ *      Unicode ranges needed by duk_unicode_is_identifier_start() and
-+ *      duk_unicode_is_identifier_part() can be dropped.  String literals
-+ *      should still be allowed to contain escaped Unicode, so this still does
-+ *      not allow removal of CESU-8 encoding of e.g. string literals.
-+ *
-+ *    * Character lookup tables for codepoints above BMP could be stripped.
-+ *
-+ *    * Strictly speaking, E5 specification requires that source code consists
-+ *      of 16-bit code units, and if not, must be conceptually converted to
-+ *      that format first.  The current lexer processes Unicode code points
-+ *      and allows characters outside the BMP.  These should be converted to
-+ *      surrogate pairs while reading the source characters into the window,
-+ *      not after tokens have been formed (as is done now).  However, the fix
-+ *      is not trivial because two characters are decoded from one codepoint.
-+ *
-+ *    * Optimize for speed as well as size.  Large if-else ladders are slow.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Various defines and file specific helper macros
-+ */
-+
-+#define DUK__MAX_RE_DECESC_DIGITS     9
-+#define DUK__MAX_RE_QUANT_DIGITS      9   /* Does not allow e.g. 2**31-1, but one more would allow overflows of u32. */
-+
-+#define DUK__LOOKUP(lex_ctx,index)    ((lex_ctx)->window[(index)])
-+#define DUK__ADVANCE(lex_ctx,count)   duk__advance_chars((lex_ctx), (count))
-+#define DUK__INITBUFFER(lex_ctx)      duk__initbuffer((lex_ctx))
-+#define DUK__APPENDBUFFER(lex_ctx,x)  duk__appendbuffer((lex_ctx), (duk_codepoint_t) (x))
-+
-+/* whether to use macros or helper function depends on call count */
-+#define DUK__ISDIGIT(x)          ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_9)
-+#define DUK__ISHEXDIGIT(x)       duk__is_hex_digit((x))
-+#define DUK__ISOCTDIGIT(x)       ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_7)
-+#define DUK__ISDIGIT03(x)        ((x) >= DUK_ASC_0 && (x) <= DUK_ASC_3)
-+#define DUK__ISDIGIT47(x)        ((x) >= DUK_ASC_4 && (x) <= DUK_ASC_7)
-+
-+/* lookup shorthands (note: assume context variable is named 'lex_ctx') */
-+#define DUK__L0()  DUK__LOOKUP(lex_ctx, 0)
-+#define DUK__L1()  DUK__LOOKUP(lex_ctx, 1)
-+#define DUK__L2()  DUK__LOOKUP(lex_ctx, 2)
-+#define DUK__L3()  DUK__LOOKUP(lex_ctx, 3)
-+#define DUK__L4()  DUK__LOOKUP(lex_ctx, 4)
-+#define DUK__L5()  DUK__LOOKUP(lex_ctx, 5)
-+
-+/* packed advance/token number macro used by multiple functions */
-+#define DUK__ADVTOK(adv,tok)  (((adv) << 8) + (tok))
-+
-+/*
-+ *  Read a character from the window leading edge and update the line counter.
-+ *
-+ *  Decodes UTF-8/CESU-8 leniently with support for code points from U+0000 to
-+ *  U+10FFFF, causing an error if the input is unparseable.  Leniency means:
-+ *
-+ *    * Unicode code point validation is intentionally not performed,
-+ *      except to check that the codepoint does not exceed 0x10ffff.
-+ *
-+ *    * In particular, surrogate pairs are allowed and not combined, which
-+ *      allows source files to represent all SourceCharacters with CESU-8.
-+ *      Broken surrogate pairs are allowed, as Ecmascript does not mandate
-+ *      their validation.
-+ *
-+ *    * Allow non-shortest UTF-8 encodings.
-+ *
-+ *  Leniency here causes few security concerns because all character data is
-+ *  decoded into Unicode codepoints before lexer processing, and is then
-+ *  re-encoded into CESU-8.  The source can be parsed as strict UTF-8 with
-+ *  a compiler option.  However, Ecmascript source characters include -all-
-+ *  16-bit unsigned integer codepoints, so leniency seems to be appropriate.
-+ *
-+ *  Note that codepoints above the BMP are not strictly SourceCharacters,
-+ *  but the lexer still accepts them as such.  Before ending up in a string
-+ *  or an identifier name, codepoints above BMP are converted into surrogate
-+ *  pairs and then CESU-8 encoded, resulting in 16-bit Unicode data as
-+ *  expected by Ecmascript.
-+ *
-+ *  An alternative approach to dealing with invalid or partial sequences
-+ *  would be to skip them and replace them with e.g. the Unicode replacement
-+ *  character U+FFFD.  This has limited utility because a replacement character
-+ *  will most likely cause a parse error, unless it occurs inside a string.
-+ *  Further, Ecmascript source is typically pure ASCII.
-+ *
-+ *  See:
-+ *
-+ *     http://en.wikipedia.org/wiki/UTF-8
-+ *     http://en.wikipedia.org/wiki/CESU-8
-+ *     http://tools.ietf.org/html/rfc3629
-+ *     http://en.wikipedia.org/wiki/UTF-8#Invalid_byte_sequences
-+ *
-+ *  Future work:
-+ *
-+ *    * Reject other invalid Unicode sequences (see Wikipedia entry for examples)
-+ *      in strict UTF-8 mode.
-+ *
-+ *    * Size optimize.  An attempt to use a 16-byte lookup table for the first
-+ *      byte resulted in a code increase though.
-+ *
-+ *    * Is checking against maximum 0x10ffff really useful?  4-byte encoding
-+ *      imposes a certain limit anyway.
-+ */
-+
-+DUK_LOCAL duk_codepoint_t duk__read_char(duk_lexer_ctx *lex_ctx) {
-+	/* attempting to reduce size of 'len' and/or 'i' resulted in larger code */
-+	duk_codepoint_t x;
-+	duk_small_int_t len;
-+	duk_small_int_t i;
-+	const duk_uint8_t *p;
-+#ifdef DUK_USE_STRICT_UTF8_SOURCE
-+	duk_codepoint_t mincp;
-+#endif
-+	duk_size_t input_offset;
-+
-+	input_offset = lex_ctx->input_offset;
-+	if (DUK_UNLIKELY(input_offset >= lex_ctx->input_length)) {
-+		/* If input_offset were assigned a negative value, it would
-+		 * result in a large positive value.  Most likely it would be
-+		 * larger than input_length and be caught here.  In any case
-+		 * no memory unsafe behavior would happen.
-+		 */
-+		return -1;
-+	}
-+
-+	p = lex_ctx->input + input_offset;
-+	x = (int) *p++;
-+
-+	if (x < 0x80L) {
-+		/* 0xxx xxxx -> fast path */
-+		len = 1;
-+		goto fastpath;
-+	} else if (x < 0xc0L) {
-+		/* 10xx xxxx -> invalid */
-+		goto error_encoding;
-+	} else if (x < 0xe0L) {
-+		/* 110x xxxx   10xx xxxx  */
-+		len = 2;
-+#ifdef DUK_USE_STRICT_UTF8_SOURCE
-+		mincp = 0x80L;
-+#endif
-+		x = x & 0x1fL;
-+	} else if (x < 0xf0L) {
-+		/* 1110 xxxx   10xx xxxx   10xx xxxx */
-+		len = 3;
-+#ifdef DUK_USE_STRICT_UTF8_SOURCE
-+		mincp = 0x800L;
-+#endif
-+		x = x & 0x0fL;
-+	} else if (x < 0xf8L) {
-+		/* 1111 0xxx   10xx xxxx   10xx xxxx   10xx xxxx */
-+		len = 4;
-+#ifdef DUK_USE_STRICT_UTF8_SOURCE
-+		mincp = 0x10000L;
-+#endif
-+		x = x & 0x07;
-+	} else {
-+		/* no point in supporting encodings of 5 or more bytes */
-+		goto error_encoding;
-+	}
-+
-+	DUK_ASSERT(lex_ctx->input_length >= lex_ctx->input_offset);
-+	if ((duk_size_t) len > (duk_size_t) (lex_ctx->input_length - lex_ctx->input_offset)) {
-+		goto error_clipped;
-+	}
-+
-+	for (i = 1; i < len; i++) {
-+		duk_small_int_t y = *p++;
-+		if ((y & 0xc0) != 0x80) {
-+			/* check that byte has the form 10xx xxxx */
-+			goto error_encoding;
-+		}
-+		x = x << 6;
-+		x += y & 0x3f;
-+	}
-+
-+	/* check final character validity */
-+
-+	if (x > 0x10ffffL) {
-+		goto error_encoding;
-+	}
-+#ifdef DUK_USE_STRICT_UTF8_SOURCE
-+	if (x < mincp || (x >= 0xd800L && x <= 0xdfffL) || x == 0xfffeL) {
-+		goto error_encoding;
-+	}
-+#endif
-+
-+	/* fall through */
-+
-+ fastpath:
-+	/* input offset tracking */
-+	lex_ctx->input_offset += len;
-+
-+	/* line tracking */
-+	if ((x == 0x000aL) ||
-+	    ((x == 0x000dL) && (lex_ctx->input_offset >= lex_ctx->input_length ||
-+	                        lex_ctx->input[lex_ctx->input_offset] != 0x000aL)) ||
-+	    (x == 0x2028L) ||
-+	    (x == 0x2029L)) {
-+		/* lookup for 0x000a above assumes shortest encoding now */
-+
-+		/* E5 Section 7.3, treat the following as newlines:
-+		 *   LF
-+		 *   CR [not followed by LF]
-+		 *   LS
-+		 *   PS
-+		 *
-+		 * For CR LF, CR is ignored if it is followed by LF, and the LF will bump
-+		 * the line number.
-+		 */
-+		lex_ctx->input_line++;
-+	}
-+
-+	return x;
-+
-+ error_clipped:   /* clipped codepoint */
-+ error_encoding:  /* invalid codepoint encoding or codepoint */
-+	DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "char decode failed");
-+	return 0;
-+}
-+
-+/*
-+ *  Advance lookup window by N characters.  Also used to fill the window
-+ *  after position is changed (call with count == DUK_LEXER_WINDOW_SIZE).
-+ *
-+ *  XXX: A lot of copying now, perhaps change to circular array or at
-+ *  least use memcpy().  For memcpy(), putting all elements of the
-+ *  window (code point, offset, line) into a struct would allow one
-+ *  memcpy() to slide the window, instead of three separate copys.
-+ */
-+
-+DUK_LOCAL void duk__advance_chars(duk_lexer_ctx *lex_ctx, duk_small_int_t count) {
-+	duk_small_int_t i, n;
-+
-+	DUK_ASSERT(count >= 0 && count <= DUK_LEXER_WINDOW_SIZE);
-+
-+	/* Without this check, gcc -O4 will complain the following for the
-+	 * first for-loop below:
-+	 *
-+	 *   duk_lexer.c:301:19: error: array subscript is above array bounds [-Werror=array-bounds]
-+	 *
-+	 * Check for range explicitly; this also protects against legitimate
-+	 * internal errors and avoids memory unsafe behavior in such cases.
-+	 */
-+	if (DUK_UNLIKELY(!(count >= 0 && count <= DUK_LEXER_WINDOW_SIZE))) {
-+		DUK_D(DUK_DPRINT("invalid count: %ld, should not happen", (long) count));
-+		DUK_ERROR(lex_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_INTERNAL_ERROR);
-+		return;  /* never here */
-+	}
-+
-+	if (count == 0) {
-+		/* allowing zero count makes some special caller flows easier */
-+		return;
-+	}
-+
-+	n = DUK_LEXER_WINDOW_SIZE - count;
-+	for (i = 0; i < n; i++) {
-+		lex_ctx->offsets[i] = lex_ctx->offsets[i + count];
-+		lex_ctx->lines[i] = lex_ctx->lines[i + count];
-+		lex_ctx->window[i] = lex_ctx->window[i + count];
-+	}
-+
-+	for (; i < DUK_LEXER_WINDOW_SIZE; i++) {
-+		lex_ctx->offsets[i] = lex_ctx->input_offset;
-+		lex_ctx->lines[i] = lex_ctx->input_line;
-+		lex_ctx->window[i] = duk__read_char(lex_ctx);
-+	}
-+}
-+
-+/*
-+ *  (Re)initialize the temporary byte buffer.  May be called extra times
-+ *  with little impact.
-+ */
-+
-+DUK_LOCAL void duk__initbuffer(duk_lexer_ctx *lex_ctx) {
-+	if (DUK_HBUFFER_DYNAMIC_GET_ALLOC_SIZE(lex_ctx->buf) < DUK_LEXER_TEMP_BUF_LIMIT) {
-+		/* Resize (zero) without realloc. */
-+		DUK_HBUFFER_DYNAMIC_SET_SIZE(lex_ctx->buf, 0);
-+	} else {
-+		duk_hbuffer_resize(lex_ctx->thr, lex_ctx->buf, 0, DUK_LEXER_TEMP_BUF_LIMIT);
-+	}
-+}
-+
-+/*
-+ *  Append a Unicode codepoint to the temporary byte buffer.  Performs
-+ *  CESU-8 surrogate pair encoding for codepoints above the BMP.
-+ *  Existing surrogate pairs are allowed and also encoded into CESU-8.
-+ */
-+
-+DUK_LOCAL void duk__appendbuffer(duk_lexer_ctx *lex_ctx, duk_codepoint_t x) {
-+	/*
-+	 *  Since character data is only generated by decoding the source or by
-+	 *  the compiler itself, we rely on the input codepoints being correct
-+	 *  and avoid a check here.
-+	 *
-+	 *  Character data can also come here through decoding of Unicode
-+	 *  escapes ("\udead\ubeef") so all 16-but unsigned values can be
-+	 *  present, even when the source file itself is strict UTF-8.
-+	 */
-+
-+	DUK_ASSERT(x >= 0 && x <= 0x10ffff);
-+
-+	duk_hbuffer_append_cesu8(lex_ctx->thr, lex_ctx->buf, (duk_ucodepoint_t) x);
-+}
-+
-+/*
-+ *  Intern the temporary byte buffer into a valstack slot
-+ *  (in practice, slot1 or slot2).
-+ */
-+
-+DUK_LOCAL void duk__internbuffer(duk_lexer_ctx *lex_ctx, duk_idx_t valstack_idx) {
-+	duk_context *ctx = (duk_context *) lex_ctx->thr;
-+
-+	DUK_ASSERT(valstack_idx == lex_ctx->slot1_idx || valstack_idx == lex_ctx->slot2_idx);
-+
-+	duk_dup(ctx, lex_ctx->buf_idx);
-+	duk_to_string(ctx, -1);
-+	duk_replace(ctx, valstack_idx);
-+}
-+
-+/*
-+ *  Init lexer context
-+ */
-+
-+DUK_INTERNAL void duk_lexer_initctx(duk_lexer_ctx *lex_ctx) {
-+	DUK_ASSERT(lex_ctx != NULL);
-+
-+	DUK_MEMZERO(lex_ctx, sizeof(*lex_ctx));
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	lex_ctx->thr = NULL;
-+	lex_ctx->input = NULL;
-+	lex_ctx->buf = NULL;
-+#endif
-+}
-+
-+/*
-+ *  Set lexer input position and reinitialize lookup window.
-+ */
-+
-+/* NB: duk_lexer_getpoint() is a macro only */
-+
-+DUK_INTERNAL void duk_lexer_setpoint(duk_lexer_ctx *lex_ctx, duk_lexer_point *pt) {
-+	DUK_ASSERT_DISABLE(pt->offset >= 0);  /* unsigned */
-+	DUK_ASSERT(pt->line >= 1);
-+	lex_ctx->input_offset = pt->offset;
-+	lex_ctx->input_line = pt->line;
-+	duk__advance_chars(lex_ctx, DUK_LEXER_WINDOW_SIZE);  /* fill window */
-+}
-+
-+/*
-+ *  Lexing helpers
-+ */
-+
-+/* numeric value of a hex digit (also covers octal and decimal digits) */
-+DUK_LOCAL duk_codepoint_t duk__hexval(duk_lexer_ctx *lex_ctx, duk_codepoint_t x) {
-+	duk_small_int_t t;
-+
-+	/* Here 'x' is a Unicode codepoint */
-+	if (DUK_LIKELY(x >= 0 && x <= 0xff)) {
-+		t = duk_hex_dectab[x];
-+		if (DUK_LIKELY(t >= 0)) {
-+			return t;
-+		}
-+	}
-+
-+	/* Throwing an error this deep makes the error rather vague, but
-+	 * saves hundreds of bytes of code.
-+	 */
-+	DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "decode error");
-+	return 0;
-+}
-+
-+/* having this as a separate function provided a size benefit */
-+DUK_LOCAL duk_bool_t duk__is_hex_digit(duk_codepoint_t x) {
-+	if (DUK_LIKELY(x >= 0 && x <= 0xff)) {
-+		return (duk_hex_dectab[x] >= 0);
-+	}
-+	return 0;
-+}
-+
-+DUK_LOCAL duk_codepoint_t duk__decode_hexesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset) {
-+	/* validation performed by duk__hexval */
-+	return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset]) << 4) |
-+	       (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1]));
-+}
-+
-+DUK_LOCAL duk_codepoint_t duk__decode_uniesc_from_window(duk_lexer_ctx *lex_ctx, duk_small_int_t lookup_offset) {
-+	/* validation performed by duk__hexval */
-+	return (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset]) << 12) |
-+	       (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 1]) << 8) |
-+	       (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 2]) << 4) |
-+	       (duk__hexval(lex_ctx, lex_ctx->window[lookup_offset + 3]));
-+}
-+
-+/*
-+ *  Eat input characters until first character of window is not
-+ *  a white space (may be -1 if EOF encountered).
-+ */
-+DUK_LOCAL void duk__eat_whitespace(duk_lexer_ctx *lex_ctx) {
-+	/* guaranteed to finish, as EOF (-1) is not a whitespace */
-+	while (duk_unicode_is_whitespace(DUK__LOOKUP(lex_ctx, 0))) {
-+		DUK__ADVANCE(lex_ctx, 1);
-+	}
-+}
-+
-+/*
-+ *  Parse Ecmascript source InputElementDiv or InputElementRegExp
-+ *  (E5 Section 7).
-+ *
-+ *  Possible results are:
-+ *    (1) a token
-+ *    (2) a line terminator
-+ *    (3) a comment
-+ *    (4) EOF
-+ *
-+ *  White space is automatically skipped from the current position (but
-+ *  not after the input element).  If input has already ended, returns
-+ *  DUK_TOK_EOF indefinitely.  If a parse error occurs, uses an DUK_ERROR()
-+ *  macro call (and hence a longjmp through current heap longjmp context).
-+ *
-+ *  The input element being matched is determined by regexp_mode; if set,
-+ *  parses a InputElementRegExp, otherwise a InputElementDiv.  The
-+ *  difference between these are handling of productions starting with a
-+ *  forward slash.
-+ *
-+ *  If strict_mode is set, recognizes additional future reserved words
-+ *  specific to strict mode, and refuses to parse octal literals.
-+ *
-+ *  The matching strategy below is to (currently) use a six character
-+ *  lookup window to quickly determine which production is the -longest-
-+ *  matching one, and then parse that.  The top-level if-else clauses
-+ *  match the first character, and the code blocks for each clause
-+ *  handle -all- alternatives for that first character.  Ecmascript
-+ *  specification uses the "longest match wins" semantics, so the order
-+ *  of the if-clauses matters.
-+ *
-+ *  Misc notes:
-+ *
-+ *    * Ecmascript numeric literals do not accept a sign character.
-+ *      Consequently e.g. "-1.0" is parsed as two tokens: a negative
-+ *      sign and a positive numeric literal.  The compiler performs
-+ *      the negation during compilation, so this has no adverse impact.
-+ *
-+ *    * There is no token for "undefined": it is just a value available
-+ *      from the global object (or simply established by doing a reference
-+ *      to an undefined value).
-+ *
-+ *    * Some contexts want Identifier tokens, which are IdentifierNames
-+ *      excluding reserved words, while some contexts want IdentifierNames
-+ *      directly.  In the latter case e.g. "while" is interpreted as an
-+ *      identifier name, not a DUK_TOK_WHILE token.  The solution here is
-+ *      to provide both token types: DUK_TOK_WHILE goes to 't' while
-+ *      DUK_TOK_IDENTIFIER goes to 't_nores', and 'slot1' always contains
-+ *      the identifier / keyword name.
-+ *
-+ *    * Directive prologue needs to identify string literals such as
-+ *      "use strict" and 'use strict', which are sensitive to line
-+ *      continuations and escape sequences.  For instance, "use\u0020strict"
-+ *      is a valid directive but is distinct from "use strict".  The solution
-+ *      here is to decode escapes while tokenizing, but to keep track of the
-+ *      number of escapes.  Directive detection can then check that the
-+ *      number of escapes is zero.
-+ *
-+ *    * Comments are expressed as DUK_TOK_COMMENT tokens, with the type
-+ *      (single- or multi-line) and contents of the comments lost.
-+ *      Furthermore, multi-line comments with one or more internal
-+ *      LineTerminator are treated as DUK_TOK_LINETERM to comply with
-+ *      automatic semicolon insertion and to avoid complicating the
-+ *      tokenization process.  See E5 Section 7.4.
-+ */
-+
-+DUK_LOCAL
-+void duk__parse_input_element_raw(duk_lexer_ctx *lex_ctx,
-+                                  duk_token *out_token,
-+                                  duk_bool_t strict_mode,
-+                                  duk_bool_t regexp_mode) {
-+	duk_codepoint_t x, y;        /* temporaries, must be signed and 32-bit to hold Unicode code points */
-+	duk_small_uint_t advtok = 0; /* (advance << 8) + token_type, updated at function end,
-+	                              * init is unnecessary but suppresses "may be used uninitialized" warnings.
-+	                              */
-+
-+	if (++lex_ctx->token_count >= lex_ctx->token_limit) {
-+		DUK_ERROR(lex_ctx->thr, DUK_ERR_RANGE_ERROR, "token limit");
-+		return;  /* unreachable */
-+	}
-+
-+	duk__eat_whitespace(lex_ctx);
-+
-+	out_token->t = DUK_TOK_EOF;
-+	out_token->t_nores = -1;  /* marker: copy t if not changed */
-+	out_token->num = DUK_DOUBLE_NAN;
-+	out_token->str1 = NULL;
-+	out_token->str2 = NULL;
-+	out_token->num_escapes = 0;
-+	out_token->start_line = lex_ctx->lines[0];
-+	out_token->start_offset = lex_ctx->offsets[0];
-+	/* out_token->lineterm set by caller */
-+
-+	duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
-+	duk_to_undefined((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx);
-+
-+	/* 'advtok' indicates how much to advance and which token id to assign
-+	 * at the end.  This shared functionality minimizes code size.  All
-+	 * code paths are required to set 'advtok' to some value, so no default
-+	 * init value is used.  Code paths calling DUK_ERROR() never return so
-+	 * they don't need to set advtok.
-+	 */
-+
-+	/*
-+	 *  Matching order:
-+	 *
-+	 *    Punctuator first chars, also covers comments, regexps
-+	 *    LineTerminator
-+	 *    Identifier or reserved word, also covers null/true/false literals
-+	 *    NumericLiteral
-+	 *    StringLiteral
-+	 *    EOF
-+	 *
-+	 *  The order does not matter as long as the longest match is
-+	 *  always correctly identified.  There are order dependencies
-+	 *  in the clauses, so it's not trivial to convert to a switch.
-+	 *
-+	 *  XXX: This is quite inefficient.  Maybe change to a switch
-+	 *  statement which handles all single character cases and then
-+	 *  use a followup if-else chain?  Switch matches need to use
-+	 *  goto to bypass the if-else chain.
-+	 */
-+
-+	x = DUK__L0();
-+	y = DUK__L1();
-+
-+	if (x == '/') {
-+		if (y == '/') {
-+			/*
-+			 *  E5 Section 7.4, allow SourceCharacter (which is any 16-bit
-+			 *  code point).
-+			 */
-+
-+			/* DUK__ADVANCE(lex_ctx, 2) would be correct here, but it unnecessary */
-+			for (;;) {
-+				x = DUK__L0();
-+				if (x < 0 || duk_unicode_is_line_terminator(x)) {
-+					break;
-+				}
-+				DUK__ADVANCE(lex_ctx, 1);
-+			}
-+			advtok = DUK__ADVTOK(0, DUK_TOK_COMMENT);
-+		} else if (y == '*') {
-+			/*
-+			 *  E5 Section 7.4.  If the multi-line comment contains a newline,
-+			 *  it is treated like a single DUK_TOK_LINETERM to facilitate
-+			 *  automatic semicolon insertion.
-+			 */
-+
-+			duk_bool_t last_asterisk = 0;
-+			advtok = DUK__ADVTOK(0, DUK_TOK_COMMENT);
-+			DUK__ADVANCE(lex_ctx, 2);
-+			for (;;) {
-+				x = DUK__L0();
-+				if (x < 0) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "eof while parsing multiline comment");
-+				}
-+				DUK__ADVANCE(lex_ctx, 1);
-+				if (last_asterisk && x == '/') {
-+					break;
-+				}
-+				if (duk_unicode_is_line_terminator(x)) {
-+					advtok = DUK__ADVTOK(0, DUK_TOK_LINETERM);
-+				}
-+				last_asterisk = (x == '*');
-+			}
-+		} else if (regexp_mode) {
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+			/*
-+			 *  "/" followed by something in regexp mode.  See E5 Section 7.8.5.
-+			 *
-+			 *  RegExp parsing is a bit complex.  First, the regexp body is delimited
-+			 *  by forward slashes, but the body may also contain forward slashes as
-+			 *  part of an escape sequence or inside a character class (delimited by
-+			 *  square brackets).  A mini state machine is used to implement these.
-+			 *
-+			 *  Further, an early (parse time) error must be thrown if the regexp
-+			 *  would cause a run-time error when used in the expression new RegExp(...).
-+			 *  Parsing here simply extracts the (candidate) regexp, and also accepts
-+			 *  invalid regular expressions (which are delimited properly).  The caller
-+			 *  (compiler) must perform final validation and regexp compilation.
-+			 *
-+			 *  RegExp first char may not be '/' (single line comment) or '*' (multi-
-+			 *  line comment).  These have already been checked above, so there is no
-+			 *  need below for special handling of the first regexp character as in
-+			 *  the E5 productions.
-+			 *
-+			 *  About unicode escapes within regexp literals:
-+			 *
-+			 *      E5 Section 7.8.5 grammar does NOT accept \uHHHH escapes.
-+			 *      However, Section 6 states that regexps accept the escapes,
-+			 *      see paragraph starting with "In string literals...".
-+			 *      The regexp grammar, which sees the decoded regexp literal
-+			 *      (after lexical parsing) DOES have a \uHHHH unicode escape.
-+			 *      So, for instance:
-+			 *
-+			 *          /\u1234/
-+			 *
-+			 *      should first be parsed by the lexical grammar as:
-+			 *
-+			 *          '\' 'u'      RegularExpressionBackslashSequence
-+			 *          '1'          RegularExpressionNonTerminator
-+			 *          '2'          RegularExpressionNonTerminator
-+			 *          '3'          RegularExpressionNonTerminator
-+			 *          '4'          RegularExpressionNonTerminator
-+			 *
-+			 *      and the escape itself is then parsed by the regexp engine.
-+			 *      This is the current implementation.
-+			 *
-+			 *  Minor spec inconsistency:
-+			 *
-+			 *      E5 Section 7.8.5 RegularExpressionBackslashSequence is:
-+			 *
-+			 *         \ RegularExpressionNonTerminator
-+			 *
-+			 *      while Section A.1 RegularExpressionBackslashSequence is:
-+			 *
-+			 *         \ NonTerminator
-+			 *
-+			 *      The latter is not normative and a typo.
-+			 *
-+			 */
-+
-+			/* first, parse regexp body roughly */
-+
-+			duk_small_int_t state = 0;  /* 0=base, 1=esc, 2=class, 3=class+esc */
-+
-+			DUK__INITBUFFER(lex_ctx);
-+			for (;;) {
-+				DUK__ADVANCE(lex_ctx, 1);  /* skip opening slash on first loop */
-+				x = DUK__L0();
-+				if (x < 0 || duk_unicode_is_line_terminator(x)) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "eof or line terminator while parsing regexp");
-+				}
-+				x = DUK__L0();  /* re-read to avoid spill / fetch */
-+				if (state == 0) {
-+					if (x == '/') {
-+						DUK__ADVANCE(lex_ctx, 1);  /* eat closing slash */
-+						break;
-+					} else if (x == '\\') {
-+						state = 1;
-+					} else if (x == '[') {
-+						state = 2;
-+					}
-+				} else if (state == 1) {
-+					state = 0;
-+				} else if (state == 2) {
-+					if (x == ']') {
-+						state = 0;
-+					} else if (x == '\\') {
-+						state = 3;
-+					}
-+				} else { /* state == 3 */
-+					state = 2;
-+				}
-+				DUK__APPENDBUFFER(lex_ctx, x);
-+			}
-+			duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
-+			out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
-+
-+			/* second, parse flags */
-+
-+			DUK__INITBUFFER(lex_ctx);
-+			for (;;) {
-+				x = DUK__L0();
-+				if (!duk_unicode_is_identifier_part(x)) {
-+					break;
-+				}
-+				x = DUK__L0();  /* re-read to avoid spill / fetch */
-+				DUK__APPENDBUFFER(lex_ctx, x);
-+				DUK__ADVANCE(lex_ctx, 1);
-+			}
-+			duk__internbuffer(lex_ctx, lex_ctx->slot2_idx);
-+			out_token->str2 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot2_idx);
-+
-+			DUK__INITBUFFER(lex_ctx);  /* free some memory */
-+
-+			/* validation of the regexp is caller's responsibility */
-+
-+			advtok = DUK__ADVTOK(0, DUK_TOK_REGEXP);
-+#else
-+			DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "regexp support disabled");
-+#endif
-+		} else if (y == '=') {
-+			/* "/=" and not in regexp mode */
-+			advtok = DUK__ADVTOK(2, DUK_TOK_DIV_EQ);
-+		} else {
-+			/* "/" and not in regexp mode */
-+			advtok = DUK__ADVTOK(1, DUK_TOK_DIV);
-+		}
-+	} else if (x == '{') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_LCURLY);
-+	} else if (x == '}') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_RCURLY);
-+	} else if (x == '(') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_LPAREN);
-+	} else if (x == ')') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_RPAREN);
-+	} else if (x == '[') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_LBRACKET);
-+	} else if (x == ']') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_RBRACKET);
-+	} else if (x == '.' && !DUK__ISDIGIT(y)) {
-+		/* Note: period followed by a digit can only start DecimalLiteral (captured below) */
-+		advtok = DUK__ADVTOK(1, DUK_TOK_PERIOD);
-+	} else if (x == ';') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_SEMICOLON);
-+	} else if (x == ',') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_COMMA);
-+	} else if (x == '<') {
-+		if (y == '<' && DUK__L2() == '=') {
-+			advtok = DUK__ADVTOK(3, DUK_TOK_ALSHIFT_EQ);
-+		} else if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_LE);
-+		} else if (y == '<') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_ALSHIFT);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_LT);
-+		}
-+	} else if (x == '>') {
-+		if (y == '>' && DUK__L2() == '>' && DUK__L3() == '=') {
-+			advtok = DUK__ADVTOK(4, DUK_TOK_RSHIFT_EQ);
-+		} else if (y == '>' && DUK__L2() == '>') {
-+			advtok = DUK__ADVTOK(3, DUK_TOK_RSHIFT);
-+		} else if (y == '>' && DUK__L2() == '=') {
-+			advtok = DUK__ADVTOK(3, DUK_TOK_ARSHIFT_EQ);
-+		} else if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_GE);
-+		} else if (y == '>') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_ARSHIFT);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_GT);
-+		}
-+	} else if (x == '=') {
-+		if (y == '=' && DUK__L2() == '=') {
-+			advtok = DUK__ADVTOK(3, DUK_TOK_SEQ);
-+		} else if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_EQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_EQUALSIGN);
-+		}
-+	} else if (x == '!') {
-+		if (y == '=' && DUK__L2() == '=') {
-+			advtok = DUK__ADVTOK(3, DUK_TOK_SNEQ);
-+		} else if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_NEQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_LNOT);
-+		}
-+	} else if (x == '+') {
-+		if (y == '+') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_INCREMENT);
-+		} else if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_ADD_EQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_ADD);
-+		}
-+	} else if (x == '-') {
-+		if (y == '-') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_DECREMENT);
-+		} else if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_SUB_EQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_SUB);
-+		}
-+	} else if (x == '*') {
-+		if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_MUL_EQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_MUL);
-+		}
-+	} else if (x == '%') {
-+		if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_MOD_EQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_MOD);
-+		}
-+	} else if (x == '&') {
-+		if (y == '&') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_LAND);
-+		} else if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_BAND_EQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_BAND);
-+		}
-+	} else if (x == '|') {
-+		if (y == '|') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_LOR);
-+		} else if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_BOR_EQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_BOR);
-+		}
-+	} else if (x == '^') {
-+		if (y == '=') {
-+			advtok = DUK__ADVTOK(2, DUK_TOK_BXOR_EQ);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_BXOR);
-+		}
-+	} else if (x == '~') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_BNOT);
-+	} else if (x == '?') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_QUESTION);
-+	} else if (x == ':') {
-+		advtok = DUK__ADVTOK(1, DUK_TOK_COLON);
-+	} else if (duk_unicode_is_line_terminator(x)) {
-+		if (x == 0x000d && y == 0x000a) {
-+			/*
-+			 *  E5 Section 7.3: CR LF is detected as a single line terminator for
-+			 *  line numbers.  Here we also detect it as a single line terminator
-+			 *  token.
-+			 */
-+			advtok = DUK__ADVTOK(2, DUK_TOK_LINETERM);
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_TOK_LINETERM);
-+		}
-+	} else if (duk_unicode_is_identifier_start(x) || x == '\\') {
-+		/*
-+		 *  Parse an identifier and then check whether it is:
-+		 *    - reserved word (keyword or other reserved word)
-+		 *    - "null"  (NullLiteral)
-+		 *    - "true"  (BooleanLiteral)
-+		 *    - "false" (BooleanLiteral)
-+		 *    - anything else => identifier
-+		 *
-+		 *  This does not follow the E5 productions cleanly, but is
-+		 *  useful and compact.
-+		 *
-+		 *  Note that identifiers may contain Unicode escapes,
-+		 *  see E5 Sections 6 and 7.6.  They must be decoded first,
-+		 *  and the result checked against allowed characters.
-+		 *  The above if-clause accepts an identifier start and an
-+		 *  '\' character -- no other token can begin with a '\'.
-+		 *
-+		 *  Note that "get" and "set" are not reserved words in E5
-+		 *  specification so they are recognized as plain identifiers
-+		 *  (the tokens DUK_TOK_GET and DUK_TOK_SET are actually not
-+		 *  used now).  The compiler needs to work around this.
-+		 *
-+		 *  Strictly speaking, following Ecmascript longest match
-+		 *  specification, an invalid escape for the first character
-+		 *  should cause a syntax error.  However, an invalid escape
-+		 *  for IdentifierParts should just terminate the identifier
-+		 *  early (longest match), and let the next tokenization
-+		 *  fail.  For instance Rhino croaks with 'foo\z' when
-+		 *  parsing the identifier.  This has little practical impact.
-+		 */
-+
-+		duk_small_int_t i, i_end;
-+		duk_bool_t first = 1;
-+		duk_hstring *str;
-+
-+		DUK__INITBUFFER(lex_ctx);
-+		for (;;) {
-+			/* re-lookup first char on first loop */
-+			if (DUK__L0() == '\\') {
-+				duk_codepoint_t ch;
-+				if (DUK__L1() != 'u') {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid unicode escape while parsing identifier");
-+				}
-+
-+				ch = duk__decode_uniesc_from_window(lex_ctx, 2);
-+
-+				/* IdentifierStart is stricter than IdentifierPart, so if the first
-+				 * character is escaped, must have a stricter check here.
-+				 */
-+				if (!(first ? duk_unicode_is_identifier_start(ch) : duk_unicode_is_identifier_part(ch))) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid unicode escaped character while parsing identifier");
-+				}
-+				DUK__APPENDBUFFER(lex_ctx, ch);
-+				DUK__ADVANCE(lex_ctx, 6);
-+
-+				/* Track number of escapes: necessary for proper keyword
-+				 * detection.
-+				 */
-+				out_token->num_escapes++;
-+			} else {
-+				/* Note: first character is checked against this.  But because
-+				 * IdentifierPart includes all IdentifierStart characters, and
-+				 * the first character (if unescaped) has already been checked
-+				 * in the if condition, this is OK.
-+				 */
-+				if (!duk_unicode_is_identifier_part(DUK__L0())) {
-+					break;
-+				}
-+				DUK__APPENDBUFFER(lex_ctx, DUK__L0());
-+				DUK__ADVANCE(lex_ctx, 1);
-+			}
-+			first = 0;
-+		}
-+
-+		duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
-+		out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
-+		str = out_token->str1;
-+		DUK_ASSERT(str != NULL);
-+		out_token->t_nores = DUK_TOK_IDENTIFIER;
-+
-+		DUK__INITBUFFER(lex_ctx);  /* free some memory */
-+
-+		/*
-+		 *  Interned identifier is compared against reserved words, which are
-+		 *  currently interned into the heap context.  See genstrings.py.
-+		 *
-+		 *  Note that an escape in the identifier disables recognition of
-+		 *  keywords; e.g. "\u0069f = 1;" is a valid statement (assigns to
-+		 *  identifier named "if").  This is not necessarily compliant,
-+		 *  see test-dec-escaped-char-in-keyword.js.
-+		 *
-+		 *  Note: "get" and "set" are awkward.  They are not officially
-+		 *  ReservedWords (and indeed e.g. "var set = 1;" is valid), and
-+		 *  must come out as DUK_TOK_IDENTIFIER.  The compiler needs to
-+		 *  work around this a bit.
-+		 */
-+
-+		/* XXX: optimize by adding the token numbers directly into the
-+		 * always interned duk_hstring objects (there should be enough
-+		 * flag bits free for that)?
-+		 */
-+
-+		i_end = (strict_mode ? DUK_STRIDX_END_RESERVED : DUK_STRIDX_START_STRICT_RESERVED);
-+
-+		advtok = DUK__ADVTOK(0, DUK_TOK_IDENTIFIER);
-+		if (out_token->num_escapes == 0) {
-+			for (i = DUK_STRIDX_START_RESERVED; i < i_end; i++) {
-+				DUK_ASSERT(i >= 0 && i < DUK_HEAP_NUM_STRINGS);
-+				if (DUK_HTHREAD_GET_STRING(lex_ctx->thr, i) == str) {
-+					advtok = DUK__ADVTOK(0, DUK_STRIDX_TO_TOK(i));
-+					break;
-+				}
-+			}
-+		}
-+	} else if (DUK__ISDIGIT(x) || (x == '.')) {
-+		/* Note: decimal number may start with a period, but must be followed by a digit */
-+
-+		/*
-+		 *  DecimalLiteral, HexIntegerLiteral, OctalIntegerLiteral
-+		 *  "pre-parsing", followed by an actual, accurate parser step.
-+		 *
-+		 *  Note: the leading sign character ('+' or '-') is -not- part of
-+		 *  the production in E5 grammar, and that the a DecimalLiteral
-+		 *  starting with a '0' must be followed by a non-digit.  Leading
-+		 *  zeroes are syntax errors and must be checked for.
-+		 *
-+		 *  XXX: the two step parsing process is quite awkward, it would
-+		 *  be more straightforward to allow numconv to parse the longest
-+		 *  valid prefix (it already does that, it only needs to indicate
-+		 *  where the input ended).  However, the lexer decodes characters
-+		 *  using a lookup window, so this is not a trivial change.
-+		 */
-+
-+		/* XXX: because of the final check below (that the literal is not
-+		 * followed by a digit), this could maybe be simplified, if we bail
-+		 * out early from a leading zero (and if there are no periods etc).
-+		 * Maybe too complex.
-+		 */
-+
-+		duk_double_t val;
-+		duk_bool_t int_only = 0;
-+		duk_bool_t allow_hex = 0;
-+		duk_small_int_t state;  /* 0=before period/exp,
-+		                         * 1=after period, before exp
-+		                         * 2=after exp, allow '+' or '-'
-+		                         * 3=after exp and exp sign
-+		                         */
-+		duk_small_uint_t s2n_flags;
-+
-+		DUK__INITBUFFER(lex_ctx);
-+		if (x == '0' && (y == 'x' || y == 'X')) {
-+			DUK__APPENDBUFFER(lex_ctx, x);
-+			DUK__APPENDBUFFER(lex_ctx, y);
-+			DUK__ADVANCE(lex_ctx, 2);
-+			int_only = 1;
-+			allow_hex = 1;
-+#ifdef DUK_USE_OCTAL_SUPPORT
-+		} else if (!strict_mode && x == '0' && DUK__ISDIGIT(y)) {
-+			/* Note: if DecimalLiteral starts with a '0', it can only be
-+			 * followed by a period or an exponent indicator which starts
-+			 * with 'e' or 'E'.  Hence the if-check above ensures that
-+			 * OctalIntegerLiteral is the only valid NumericLiteral
-+			 * alternative at this point (even if y is, say, '9').
-+			 */
-+
-+			DUK__APPENDBUFFER(lex_ctx, x);
-+			DUK__ADVANCE(lex_ctx, 1);
-+			int_only = 1;
-+#endif
-+		}
-+
-+		state = 0;
-+		for (;;) {
-+			x = DUK__L0();  /* re-lookup curr char on first round */
-+			if (DUK__ISDIGIT(x)) {
-+				/* Note: intentionally allow leading zeroes here, as the
-+				 * actual parser will check for them.
-+				 */
-+				if (state == 2) {
-+					state = 3;
-+				}
-+			} else if (allow_hex && DUK__ISHEXDIGIT(x)) {
-+				/* Note: 'e' and 'E' are also accepted here. */
-+				;
-+			} else if (x == '.') {
-+				if (state >= 1 || int_only) {
-+					break;
-+				} else {
-+					state = 1;
-+				}
-+			} else if (x == 'e' || x == 'E') {
-+				if (state >= 2 || int_only) {
-+					break;
-+				} else {
-+					state = 2;
-+				}
-+			} else if (x == '-' || x == '+') {
-+				if (state != 2) {
-+					break;
-+				} else {
-+					state = 3;
-+				}
-+			} else {
-+				break;
-+			}
-+			DUK__APPENDBUFFER(lex_ctx, x);
-+			DUK__ADVANCE(lex_ctx, 1);
-+		}
-+
-+		/* XXX: better coercion */
-+		duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
-+
-+		s2n_flags = DUK_S2N_FLAG_ALLOW_EXP |
-+		            DUK_S2N_FLAG_ALLOW_FRAC |
-+		            DUK_S2N_FLAG_ALLOW_NAKED_FRAC |
-+		            DUK_S2N_FLAG_ALLOW_EMPTY_FRAC |
-+#ifdef DUK_USE_OCTAL_SUPPORT
-+		            (strict_mode ? 0 : DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT) |
-+#endif
-+		            DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT;
-+
-+		duk_dup((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
-+		duk_numconv_parse((duk_context *) lex_ctx->thr, 10 /*radix*/, s2n_flags);
-+		val = duk_to_number((duk_context *) lex_ctx->thr, -1);
-+		if (DUK_ISNAN(val)) {
-+			DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "invalid numeric literal");
-+		}
-+		duk_replace((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);  /* could also just pop? */
-+
-+		DUK__INITBUFFER(lex_ctx);  /* free some memory */
-+
-+		/* Section 7.8.3 (note): NumericLiteral must be followed by something other than
-+		 * IdentifierStart or DecimalDigit.
-+		 */
-+
-+		if (DUK__ISDIGIT(DUK__L0()) || duk_unicode_is_identifier_start(DUK__L0())) {
-+			DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "invalid numeric literal");
-+		}
-+
-+		out_token->num = val;
-+		advtok = DUK__ADVTOK(0, DUK_TOK_NUMBER);
-+	} else if (x == '"' || x == '\'') {
-+		duk_small_int_t quote = x;  /* Note: duk_uint8_t type yields larger code */
-+		duk_small_int_t adv;
-+
-+		DUK__INITBUFFER(lex_ctx);
-+		for (;;) {
-+			DUK__ADVANCE(lex_ctx, 1);  /* eat opening quote on first loop */
-+			x = DUK__L0();
-+			if (x < 0 || duk_unicode_is_line_terminator(x)) {
-+				DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+				          "eof or line terminator while parsing string literal");
-+			}
-+			if (x == quote) {
-+				DUK__ADVANCE(lex_ctx, 1);  /* eat closing quote */
-+				break;
-+			}
-+			if (x == '\\') {
-+				/* DUK__L0        -> '\' char
-+				 * DUK__L1 ... DUK__L5 -> more lookup
-+				 */
-+
-+				x = DUK__L1();
-+				y = DUK__L2();
-+
-+				/* How much to advance before next loop; note that next loop
-+				 * will advance by 1 anyway, so -1 from the total escape
-+				 * length (e.g. len('\uXXXX') - 1 = 6 - 1).  As a default,
-+				 * 1 is good.
-+				 */
-+				adv = 2 - 1;  /* note: long live range */
-+
-+				if (x < 0) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "eof while parsing string literal");
-+				}
-+				if (duk_unicode_is_line_terminator(x)) {
-+					/* line continuation */
-+					if (x == 0x000d && y == 0x000a) {
-+						/* CR LF again a special case */
-+						adv = 3 - 1;
-+					}
-+				} else if (x == '\'') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x0027);
-+				} else if (x == '"') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x0022);
-+				} else if (x == '\\') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x005c);
-+				} else if (x == 'b') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x0008);
-+				} else if (x == 'f') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x000c);
-+				} else if (x == 'n') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x000a);
-+				} else if (x == 'r') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x000d);
-+				} else if (x == 't') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x0009);
-+				} else if (x == 'v') {
-+					DUK__APPENDBUFFER(lex_ctx, 0x000b);
-+				} else if (x == 'x') {
-+					adv = 4 - 1;
-+					DUK__APPENDBUFFER(lex_ctx, duk__decode_hexesc_from_window(lex_ctx, 2));
-+				} else if (x == 'u') {
-+					adv = 6 - 1;
-+					DUK__APPENDBUFFER(lex_ctx, duk__decode_uniesc_from_window(lex_ctx, 2));
-+				} else if (DUK__ISDIGIT(x)) {
-+					duk_codepoint_t ch = 0;  /* initialized to avoid warnings of unused var */
-+
-+					/*
-+					 *  Octal escape or zero escape:
-+					 *    \0                                     (lookahead not DecimalDigit)
-+					 *    \1 ... \7                              (lookahead not DecimalDigit)
-+					 *    \ZeroToThree OctalDigit                (lookahead not DecimalDigit)
-+					 *    \FourToSeven OctalDigit                (no lookahead restrictions)
-+					 *    \ZeroToThree OctalDigit OctalDigit     (no lookahead restrictions)
-+					 *
-+					 *  Zero escape is part of the standard syntax.  Octal escapes are
-+					 *  defined in E5 Section B.1.2, and are only allowed in non-strict mode.
-+					 *  Any other productions starting with a decimal digit are invalid.
-+					 */
-+
-+					if (x == '0' && !DUK__ISDIGIT(y)) {
-+						/* Zero escape (also allowed in non-strict mode) */
-+						ch = 0;
-+						/* adv = 2 - 1 default OK */
-+#ifdef DUK_USE_OCTAL_SUPPORT
-+					} else if (strict_mode) {
-+						/* No other escape beginning with a digit in strict mode */
-+						DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+						          "invalid escape while parsing string literal");
-+					} else if (DUK__ISDIGIT03(x) && DUK__ISOCTDIGIT(y) && DUK__ISOCTDIGIT(DUK__L3())) {
-+						/* Three digit octal escape, digits validated. */
-+						adv = 4 - 1;
-+						ch = (duk__hexval(lex_ctx, x) << 6) +
-+						     (duk__hexval(lex_ctx, y) << 3) +
-+						     duk__hexval(lex_ctx, DUK__L3());
-+					} else if (((DUK__ISDIGIT03(x) && !DUK__ISDIGIT(DUK__L3())) || DUK__ISDIGIT47(x)) &&
-+					           DUK__ISOCTDIGIT(y)) {
-+						/* Two digit octal escape, digits validated.
-+						 *
-+						 * The if-condition is a bit tricky.  We could catch e.g.
-+						 * '\039' in the three-digit escape and fail it there (by
-+					         * validating the digits), but we want to avoid extra
-+						 * additional validation code.
-+						 */
-+						adv = 3 - 1;
-+						ch = (duk__hexval(lex_ctx, x) << 3) +
-+						     duk__hexval(lex_ctx, y);
-+					} else if (DUK__ISDIGIT(x) && !DUK__ISDIGIT(y)) {
-+						/* One digit octal escape, digit validated. */
-+						/* adv = 2 default OK */
-+						ch = duk__hexval(lex_ctx, x);
-+#else
-+					/* fall through to error */
-+#endif
-+					} else {
-+						DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+						          "invalid escape while parsing string literal");
-+					}
-+
-+					DUK__APPENDBUFFER(lex_ctx, ch);
-+				} else {
-+					/* escaped NonEscapeCharacter */
-+					DUK__APPENDBUFFER(lex_ctx, x);
-+				}
-+				DUK__ADVANCE(lex_ctx, adv);
-+
-+				/* Track number of escapes; count not really needed but directive
-+				 * prologues need to detect whether there were any escapes or line
-+				 * continuations or not.
-+				 */
-+				out_token->num_escapes++;
-+			} else {
-+				/* part of string */
-+				DUK__APPENDBUFFER(lex_ctx, x);
-+			}
-+		}
-+
-+		duk__internbuffer(lex_ctx, lex_ctx->slot1_idx);
-+		out_token->str1 = duk_get_hstring((duk_context *) lex_ctx->thr, lex_ctx->slot1_idx);
-+
-+		DUK__INITBUFFER(lex_ctx);  /* free some memory */
-+
-+		advtok = DUK__ADVTOK(0, DUK_TOK_STRING);
-+	} else if (x < 0) {
-+		advtok = DUK__ADVTOK(0, DUK_TOK_EOF);
-+	} else {
-+		DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR, "error parsing token");
-+	}
-+
-+	/*
-+	 *  Shared exit path
-+	 */
-+
-+	DUK__ADVANCE(lex_ctx, advtok >> 8);
-+	out_token->t = advtok & 0xff;
-+	if (out_token->t_nores < 0) {
-+		out_token->t_nores = out_token->t;
-+	}
-+}
-+
-+/*
-+ *  Tokenize input until a non-whitespace, non-lineterm token is found.
-+ *  Note in the output token whether a lineterm token preceded the starting
-+ *  point (inclusive) and the result token.  This information is needed for
-+ *  automatic semicolon insertion.
-+ *
-+ *  Future work:
-+ *
-+ *    * Merge with duk__parse_input_element_raw() because only this function is
-+ *      called in practice.
-+ */
-+
-+/* XXX: change mode flags into one flags argument? */
-+
-+DUK_INTERNAL
-+void duk_lexer_parse_js_input_element(duk_lexer_ctx *lex_ctx,
-+                                      duk_token *out_token,
-+                                      duk_bool_t strict_mode,
-+                                      duk_bool_t regexp_mode) {
-+	duk_small_int_t tok;
-+	duk_bool_t got_lineterm = 0;  /* got lineterm preceding non-whitespace, non-lineterm token */
-+
-+	for (;;) {
-+		duk__parse_input_element_raw(lex_ctx, out_token, strict_mode, regexp_mode);
-+		tok = out_token->t;
-+
-+		DUK_DDD(DUK_DDDPRINT("RAWTOKEN: %ld (line %ld)",
-+		                     (long) tok, (long) out_token->start_line));
-+
-+		if (tok == DUK_TOK_COMMENT) {
-+			/* single-line comment or multi-line comment without an internal lineterm */
-+			continue;
-+		} else if (tok == DUK_TOK_LINETERM) {
-+			/* lineterm or multi-line comment with an internal lineterm */
-+			got_lineterm = 1;
-+			continue;
-+		} else {
-+			break;
-+		}
-+	}
-+
-+	out_token->lineterm = got_lineterm;
-+
-+	/* Automatic semicolon insertion is allowed if a token is preceded
-+	 * by line terminator(s), or terminates a statement list (right curly
-+	 * or EOF).
-+	 */
-+	if (got_lineterm || tok == DUK_TOK_RCURLY || tok == DUK_TOK_EOF) {
-+		out_token->allow_auto_semi = 1;
-+	} else {
-+		out_token->allow_auto_semi = 0;
-+	}
-+}
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+
-+/*
-+ *  Parse a RegExp token.  The grammar is described in E5 Section 15.10.
-+ *  Terminal constructions (such as quantifiers) are parsed directly here.
-+ *
-+ *  0xffffffffU is used as a marker for "infinity" in quantifiers.  Further,
-+ *  DUK__MAX_RE_QUANT_DIGITS limits the maximum number of digits that
-+ *  will be accepted for a quantifier.
-+ */
-+
-+DUK_INTERNAL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token *out_token) {
-+	duk_small_int_t advtok = 0;  /* init is unnecessary but suppresses "may be used uninitialized" warnings */
-+	duk_codepoint_t x, y;
-+
-+	if (++lex_ctx->token_count >= lex_ctx->token_limit) {
-+		DUK_ERROR(lex_ctx->thr, DUK_ERR_RANGE_ERROR, "token limit");
-+		return;  /* unreachable */
-+	}
-+
-+	DUK_MEMZERO(out_token, sizeof(*out_token));
-+
-+	x = DUK__L0();
-+	y = DUK__L1();
-+
-+	DUK_DDD(DUK_DDDPRINT("parsing regexp token, L0=%ld, L1=%ld", (long) x, (long) y));
-+
-+	switch (x) {
-+	case '|': {
-+		advtok = DUK__ADVTOK(1, DUK_RETOK_DISJUNCTION);
-+		break;
-+	}
-+	case '^': {
-+		advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_START);
-+		break;
-+	}
-+	case '$': {
-+		advtok = DUK__ADVTOK(1, DUK_RETOK_ASSERT_END);
-+		break;
-+	}
-+	case '?': {
-+		out_token->qmin = 0;
-+		out_token->qmax = 1;
-+		if (y == '?') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
-+			out_token->greedy = 0;
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
-+			out_token->greedy = 1;
-+		}
-+		break;
-+	}
-+	case '*': {
-+		out_token->qmin = 0;
-+		out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
-+		if (y == '?') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
-+			out_token->greedy = 0;
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
-+			out_token->greedy = 1;
-+		}
-+		break;
-+	}
-+	case '+': {
-+		out_token->qmin = 1;
-+		out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
-+		if (y == '?') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_QUANTIFIER);
-+			out_token->greedy = 0;
-+		} else {
-+			advtok = DUK__ADVTOK(1, DUK_RETOK_QUANTIFIER);
-+			out_token->greedy = 1;
-+		}
-+		break;
-+	}
-+	case '{': {
-+		/* Production allows 'DecimalDigits', including leading zeroes */
-+		duk_uint_fast32_t val1 = 0;
-+		duk_uint_fast32_t val2 = DUK_RE_QUANTIFIER_INFINITE;
-+		duk_small_int_t digits = 0;
-+		for (;;) {
-+			DUK__ADVANCE(lex_ctx, 1);  /* eat '{' on entry */
-+			x = DUK__L0();
-+			if (DUK__ISDIGIT(x)) {
-+				if (digits >= DUK__MAX_RE_QUANT_DIGITS) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid regexp quantifier (too many digits)");
-+				}
-+				digits++;
-+				val1 = val1 * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x);
-+			} else if (x == ',') {
-+				if (val2 != DUK_RE_QUANTIFIER_INFINITE) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid regexp quantifier (double comma)");
-+				}
-+				if (DUK__L1() == '}') {
-+					/* form: { DecimalDigits , }, val1 = min count */
-+					if (digits == 0) {
-+						DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+						          "invalid regexp quantifier (missing digits)");
-+					}
-+					out_token->qmin = val1;
-+					out_token->qmax = DUK_RE_QUANTIFIER_INFINITE;
-+					DUK__ADVANCE(lex_ctx, 2);
-+					break;
-+				}
-+				val2 = val1;
-+				val1 = 0;
-+				digits = 0;  /* not strictly necessary because of lookahead '}' above */
-+			} else if (x == '}') {
-+				if (digits == 0) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid regexp quantifier (missing digits)");
-+				}
-+				if (val2 != DUK_RE_QUANTIFIER_INFINITE) {
-+					/* val2 = min count, val1 = max count */
-+					out_token->qmin = val2;
-+					out_token->qmax = val1;
-+				} else {
-+					/* val1 = count */
-+					out_token->qmin = val1;
-+					out_token->qmax = val1;
-+				}
-+				DUK__ADVANCE(lex_ctx, 1);
-+				break;
-+			} else {
-+				DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+				          "invalid regexp quantifier (unknown char)");
-+			}
-+		}
-+		if (DUK__L0() == '?') {
-+			out_token->greedy = 0;
-+			DUK__ADVANCE(lex_ctx, 1);
-+		} else {
-+			out_token->greedy = 1;
-+		}
-+		advtok = DUK__ADVTOK(0, DUK_RETOK_QUANTIFIER);
-+		break;
-+	}
-+	case '.': {
-+		advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_PERIOD);
-+		break;
-+	}
-+	case '\\': {
-+		/* The E5.1 specification does not seem to allow IdentifierPart characters
-+		 * to be used as identity escapes.  Unfortunately this includes '$', which
-+		 * cannot be escaped as '\$'; it needs to be escaped e.g. as '\u0024'.
-+		 * Many other implementations (including V8 and Rhino, for instance) do
-+		 * accept '\$' as a valid identity escape, which is quite pragmatic.
-+		 * See: test-regexp-identity-escape-dollar.js.
-+		 */
-+
-+		advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR);  /* default: char escape (two chars) */
-+		if (y == 'b') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ASSERT_WORD_BOUNDARY);
-+		} else if (y == 'B') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY);
-+		} else if (y == 'f') {
-+			out_token->num = 0x000c;
-+		} else if (y == 'n') {
-+			out_token->num = 0x000a;
-+		} else if (y == 't') {
-+			out_token->num = 0x0009;
-+		} else if (y == 'r') {
-+			out_token->num = 0x000d;
-+		} else if (y == 'v') {
-+			out_token->num = 0x000b;
-+		} else if (y == 'c') {
-+			x = DUK__L2();
-+			if ((x >= 'a' && x <= 'z') ||
-+			    (x >= 'A' && x <= 'Z')) {
-+				out_token->num = (x % 32);
-+				advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_CHAR);
-+			} else {
-+				DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+				          "invalid regexp control escape");
-+			}
-+		} else if (y == 'x') {
-+			out_token->num = duk__decode_hexesc_from_window(lex_ctx, 2);
-+			advtok = DUK__ADVTOK(4, DUK_RETOK_ATOM_CHAR);
-+		} else if (y == 'u') {
-+			out_token->num = duk__decode_uniesc_from_window(lex_ctx, 2);
-+			advtok = DUK__ADVTOK(6, DUK_RETOK_ATOM_CHAR);
-+		} else if (y == 'd') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_DIGIT);
-+		} else if (y == 'D') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_DIGIT);
-+		} else if (y == 's') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WHITE);
-+		} else if (y == 'S') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_WHITE);
-+		} else if (y == 'w') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_WORD_CHAR);
-+		} else if (y == 'W') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_NOT_WORD_CHAR);
-+		} else if (DUK__ISDIGIT(y)) {
-+			/* E5 Section 15.10.2.11 */
-+			if (y == '0') {
-+				if (DUK__ISDIGIT(DUK__L2())) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid regexp escape");
-+				}
-+				out_token->num = 0x0000;
-+				advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_CHAR);
-+			} else {
-+				/* XXX: shared parsing? */
-+				duk_uint_fast32_t val = 0;
-+				duk_small_int_t i;
-+				for (i = 0; ; i++) {
-+					if (i >= DUK__MAX_RE_DECESC_DIGITS) {
-+						DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+						          "invalid regexp escape (decimal escape too long)");
-+					}
-+					DUK__ADVANCE(lex_ctx, 1);  /* eat backslash on entry */
-+					x = DUK__L0();
-+					if (!DUK__ISDIGIT(x)) {
-+						break;
-+					}
-+					val = val * 10 + (duk_uint_fast32_t) duk__hexval(lex_ctx, x);
-+				}
-+				/* DUK__L0() cannot be a digit, because the loop doesn't terminate if it is */
-+				advtok = DUK__ADVTOK(0, DUK_RETOK_ATOM_BACKREFERENCE);
-+				out_token->num = val;
-+			}
-+		} else if ((y >= 0 && !duk_unicode_is_identifier_part(y)) ||
-+#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE)
-+		           y == '$' ||
-+#endif
-+		           y == DUK_UNICODE_CP_ZWNJ ||
-+		           y == DUK_UNICODE_CP_ZWJ) {
-+			/* IdentityEscape, with dollar added as a valid additional
-+			 * non-standard escape (see test-regexp-identity-escape-dollar.js).
-+			 * Careful not to match end-of-buffer (<0) here.
-+			 */
-+			out_token->num = y;
-+		} else {
-+			DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+			          "invalid regexp escape");
-+		}
-+		break;
-+	}
-+	case '(': {
-+		/* XXX: naming is inconsistent: ATOM_END_GROUP ends an ASSERT_START_LOOKAHEAD */
-+
-+		if (y == '?') {
-+			if (DUK__L2() == '=') {
-+				/* (?= */
-+				advtok = DUK__ADVTOK(3, DUK_RETOK_ASSERT_START_POS_LOOKAHEAD);
-+			} else if (DUK__L2() == '!') {
-+				/* (?! */
-+				advtok = DUK__ADVTOK(3, DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD);
-+			} else if (DUK__L2() == ':') {
-+				/* (?: */
-+				advtok = DUK__ADVTOK(3, DUK_RETOK_ATOM_START_NONCAPTURE_GROUP);
-+			}
-+		} else {
-+			/* ( */
-+			advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_START_CAPTURE_GROUP);
-+		}
-+		break;
-+	}
-+	case ')': {
-+		advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_END_GROUP);
-+		break;
-+	}
-+	case '[': {
-+		/*
-+		 *  To avoid creating a heavy intermediate value for the list of ranges,
-+		 *  only the start token ('[' or '[^') is parsed here.  The regexp
-+		 *  compiler parses the ranges itself.
-+		 */
-+		advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_START_CHARCLASS);
-+		if (y == '^') {
-+			advtok = DUK__ADVTOK(2, DUK_RETOK_ATOM_START_CHARCLASS_INVERTED);
-+		}
-+		break;
-+	}
-+	case ']':
-+	case '}': {
-+		/* Although these could be parsed as PatternCharacters unambiguously (here),
-+		 * E5 Section 15.10.1 grammar explicitly forbids these as PatternCharacters.
-+		 */
-+		DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+		          "invalid regexp character");
-+		break;
-+	}
-+	case -1: {
-+		/* EOF */
-+		advtok = DUK__ADVTOK(0, DUK_TOK_EOF);
-+		break;
-+	}
-+	default: {
-+		/* PatternCharacter, all excluded characters are matched by cases above */
-+		advtok = DUK__ADVTOK(1, DUK_RETOK_ATOM_CHAR);
-+		out_token->num = x;
-+		break;
-+	}
-+	}
-+
-+	/*
-+	 *  Shared exit path
-+	 */
-+
-+	DUK__ADVANCE(lex_ctx, advtok >> 8);
-+	out_token->t = advtok & 0xff;
-+}
-+
-+/*
-+ *  Special parser for character classes; calls callback for every
-+ *  range parsed and returns the number of ranges present.
-+ */
-+
-+/* XXX: this duplicates functionality in duk_regexp.c where a similar loop is
-+ * required anyway.  We could use that BUT we need to update the regexp compiler
-+ * 'nranges' too.  Work this out a bit more cleanly to save space.
-+ */
-+
-+/* XXX: the handling of character range detection is a bit convoluted.
-+ * Try to simplify and make smaller.
-+ */
-+
-+/* XXX: logic for handling character ranges is now incorrect, it will accept
-+ * e.g. [\d-z] whereas it should croak from it?  SMJS accepts this too, though.
-+ *
-+ * Needs a read through and a lot of additional tests.
-+ */
-+
-+DUK_LOCAL
-+void duk__emit_u16_direct_ranges(duk_lexer_ctx *lex_ctx,
-+                                 duk_re_range_callback gen_range,
-+                                 void *userdata,
-+                                 duk_uint16_t *ranges,
-+                                 duk_small_int_t num) {
-+	duk_uint16_t *ranges_end;
-+
-+	DUK_UNREF(lex_ctx);
-+
-+	ranges_end = ranges + num;
-+	while (ranges < ranges_end) {
-+		/* mark range 'direct', bypass canonicalization (see Wiki) */
-+		gen_range(userdata, (duk_codepoint_t) ranges[0], (duk_codepoint_t) ranges[1], 1);
-+		ranges += 2;
-+	}
-+}
-+
-+DUK_INTERNAL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata) {
-+	duk_codepoint_t start = -1;
-+	duk_codepoint_t ch;
-+	duk_codepoint_t x;
-+	duk_bool_t dash = 0;
-+
-+	DUK_DD(DUK_DDPRINT("parsing regexp ranges"));
-+
-+	for (;;) {
-+		x = DUK__L0();
-+		DUK__ADVANCE(lex_ctx, 1);
-+
-+		ch = -1;  /* not strictly necessary, but avoids "uninitialized variable" warnings */
-+		DUK_UNREF(ch);
-+
-+		if (x < 0) {
-+			DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+			          "eof while parsing character class");
-+		} else if (x == ']') {
-+			DUK_ASSERT(!dash);  /* lookup should prevent this */
-+			if (start >= 0) {
-+				gen_range(userdata, start, start, 0);
-+			}
-+			break;
-+		} else if (x == '-') {
-+			if (start >= 0 && !dash && DUK__L0() != ']') {
-+				/* '-' as a range indicator */
-+				dash = 1;
-+				continue;
-+			} else {
-+				/* '-' verbatim */
-+				ch = x;
-+			}
-+		} else if (x == '\\') {
-+			/*
-+			 *  The escapes are same as outside a character class, except that \b has a
-+			 *  different meaning, and \B and backreferences are prohibited (see E5
-+			 *  Section 15.10.2.19).  However, it's difficult to share code because we
-+			 *  handle e.g. "\n" very differently: here we generate a single character
-+			 *  range for it.
-+			 */
-+
-+			x = DUK__L0();
-+			DUK__ADVANCE(lex_ctx, 1);
-+
-+			if (x == 'b') {
-+				/* Note: '\b' in char class is different than outside (assertion),
-+				 * '\B' is not allowed and is caught by the duk_unicode_is_identifier_part()
-+				 * check below.
-+				 */
-+				ch = 0x0008;
-+			} else if (x == 'f') {
-+				ch = 0x000c;
-+			} else if (x == 'n') {
-+				ch = 0x000a;
-+			} else if (x == 't') {
-+				ch = 0x0009;
-+			} else if (x == 'r') {
-+				ch = 0x000d;
-+			} else if (x == 'v') {
-+				ch = 0x000b;
-+			} else if (x == 'c') {
-+				x = DUK__L0();
-+				DUK__ADVANCE(lex_ctx, 1);
-+				if ((x >= 'a' && x <= 'z') ||
-+				    (x >= 'A' && x <= 'Z')) {
-+					ch = (x % 32);
-+				} else {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid regexp control escape");
-+					return;  /* never reached, but avoids warnings of
-+					          * potentially unused variables.
-+					          */
-+				}
-+			} else if (x == 'x') {
-+				ch = duk__decode_hexesc_from_window(lex_ctx, 0);
-+				DUK__ADVANCE(lex_ctx, 2);
-+			} else if (x == 'u') {
-+				ch = duk__decode_uniesc_from_window(lex_ctx, 0);
-+				DUK__ADVANCE(lex_ctx, 4);
-+			} else if (x == 'd') {
-+				duk__emit_u16_direct_ranges(lex_ctx,
-+				                            gen_range,
-+				                            userdata,
-+				                            duk_unicode_re_ranges_digit,
-+				                            sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t));
-+				ch = -1;
-+			} else if (x == 'D') {
-+				duk__emit_u16_direct_ranges(lex_ctx,
-+				                            gen_range,
-+				                            userdata,
-+				                            duk_unicode_re_ranges_not_digit,
-+				                            sizeof(duk_unicode_re_ranges_not_digit) / sizeof(duk_uint16_t));
-+				ch = -1;
-+			} else if (x == 's') {
-+				duk__emit_u16_direct_ranges(lex_ctx,
-+				                            gen_range,
-+				                            userdata,
-+				                            duk_unicode_re_ranges_white,
-+				                            sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t));
-+				ch = -1;
-+			} else if (x == 'S') {
-+				duk__emit_u16_direct_ranges(lex_ctx,
-+				                            gen_range,
-+				                            userdata,
-+				                            duk_unicode_re_ranges_not_white,
-+				                            sizeof(duk_unicode_re_ranges_not_white) / sizeof(duk_uint16_t));
-+				ch = -1;
-+			} else if (x == 'w') {
-+				duk__emit_u16_direct_ranges(lex_ctx,
-+				                            gen_range,
-+				                            userdata,
-+				                            duk_unicode_re_ranges_wordchar,
-+				                            sizeof(duk_unicode_re_ranges_wordchar) / sizeof(duk_uint16_t));
-+				ch = -1;
-+			} else if (x == 'W') {
-+				duk__emit_u16_direct_ranges(lex_ctx,
-+				                            gen_range,
-+				                            userdata,
-+				                            duk_unicode_re_ranges_not_wordchar,
-+				                            sizeof(duk_unicode_re_ranges_not_wordchar) / sizeof(duk_uint16_t));
-+				ch = -1;
-+			} else if (DUK__ISDIGIT(x)) {
-+				/* DecimalEscape, only \0 is allowed, no leading zeroes are allowed */
-+				if (x == '0' && !DUK__ISDIGIT(DUK__L0())) {
-+					ch = 0x0000;
-+				} else {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid decimal escape");
-+				}
-+			} else if (!duk_unicode_is_identifier_part(x)
-+#if defined(DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE)
-+			           || x == '$'
-+#endif
-+			          ) {
-+				/* IdentityEscape */
-+				ch = x;
-+			} else {
-+				DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+				          "invalid regexp escape");
-+			}
-+		} else {
-+			/* character represents itself */
-+			ch = x;
-+		}
-+
-+		/* ch is a literal character here or -1 if parsed entity was
-+		 * an escape such as "\s".
-+		 */
-+
-+		if (ch < 0) {
-+			/* multi-character sets not allowed as part of ranges, see
-+			 * E5 Section 15.10.2.15, abstract operation CharacterRange.
-+			 */
-+			if (start >= 0) {
-+				if (dash) {
-+					DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+					          "invalid range");
-+				} else {
-+					gen_range(userdata, start, start, 0);
-+					start = -1;
-+					/* dash is already 0 */
-+				}
-+			}
-+		} else {
-+			if (start >= 0) {
-+				if (dash) {
-+					if (start > ch) {
-+						DUK_ERROR(lex_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+						          "invalid range");
-+					}
-+					gen_range(userdata, start, ch, 0);
-+					start = -1;
-+					dash = 0;
-+				} else {
-+					gen_range(userdata, start, start, 0);
-+					start = ch;
-+					/* dash is already 0 */
-+				}
-+			} else {
-+				start = ch;
-+			}
-+		}
-+	}
-+
-+	return;
-+}
-+
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+#line 1 "duk_numconv.c"
-+/*
-+ *  Number-to-string and string-to-number conversions.
-+ *
-+ *  Slow path number-to-string and string-to-number conversion is based on
-+ *  a Dragon4 variant, with fast paths for small integers.  Big integer
-+ *  arithmetic is needed for guaranteeing that the conversion is correct
-+ *  and uses a minimum number of digits.  The big number arithmetic has a
-+ *  fixed maximum size and does not require dynamic allocations.
-+ *
-+ *  See: doc/number-conversion.txt.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#define DUK__IEEE_DOUBLE_EXP_BIAS  1023
-+#define DUK__IEEE_DOUBLE_EXP_MIN   (-1022)   /* biased exp == 0 -> denormal, exp -1022 */
-+
-+#define DUK__DIGITCHAR(x)  duk_lc_digits[(x)]
-+
-+/*
-+ *  Tables generated with src/gennumdigits.py.
-+ *
-+ *  duk__str2num_digits_for_radix indicates, for each radix, how many input
-+ *  digits should be considered significant for string-to-number conversion.
-+ *  The input is also padded to this many digits to give the Dragon4
-+ *  conversion enough (apparent) precision to work with.
-+ *
-+ *  duk__str2num_exp_limits indicates, for each radix, the radix-specific
-+ *  minimum/maximum exponent values (for a Dragon4 integer mantissa)
-+ *  below and above which the number is guaranteed to underflow to zero
-+ *  or overflow to Infinity.  This allows parsing to keep bigint values
-+ *  bounded.
-+ */
-+
-+DUK_LOCAL const duk_uint8_t duk__str2num_digits_for_radix[] = {
-+	69, 44, 35, 30, 27, 25, 23, 22, 20, 20,    /* 2 to 11 */
-+	20, 19, 19, 18, 18, 17, 17, 17, 16, 16,    /* 12 to 21 */
-+	16, 16, 16, 15, 15, 15, 15, 15, 15, 14,    /* 22 to 31 */
-+	14, 14, 14, 14, 14                         /* 31 to 36 */
-+};
-+
-+typedef struct {
-+	duk_int16_t upper;
-+	duk_int16_t lower;
-+} duk__exp_limits;
-+
-+DUK_LOCAL const duk__exp_limits duk__str2num_exp_limits[] = {
-+	{ 957, -1147 }, { 605, -725 },  { 479, -575 },  { 414, -496 },
-+	{ 372, -446 },  { 342, -411 },  { 321, -384 },  { 304, -364 },
-+	{ 291, -346 },  { 279, -334 },  { 268, -323 },  { 260, -312 },
-+	{ 252, -304 },  { 247, -296 },  { 240, -289 },  { 236, -283 },
-+	{ 231, -278 },  { 227, -273 },  { 223, -267 },  { 220, -263 },
-+	{ 216, -260 },  { 213, -256 },  { 210, -253 },  { 208, -249 },
-+	{ 205, -246 },  { 203, -244 },  { 201, -241 },  { 198, -239 },
-+	{ 196, -237 },  { 195, -234 },  { 193, -232 },  { 191, -230 },
-+	{ 190, -228 },  { 188, -226 },  { 187, -225 },
-+};
-+
-+/*
-+ *  Limited functionality bigint implementation.
-+ *
-+ *  Restricted to non-negative numbers with less than 32 * DUK__BI_MAX_PARTS bits,
-+ *  with the caller responsible for ensuring this is never exceeded.  No memory
-+ *  allocation (except stack) is needed for bigint computation.  Operations
-+ *  have been tailored for number conversion needs.
-+ *
-+ *  Argument order is "assignment order", i.e. target first, then arguments:
-+ *  x <- y * z  -->  duk__bi_mul(x, y, z);
-+ */
-+
-+/* This upper value has been experimentally determined; debug build will check
-+ * bigint size with assertions.
-+ */
-+#define DUK__BI_MAX_PARTS  37  /* 37x32 = 1184 bits */
-+
-+#ifdef DUK_USE_DDDPRINT
-+#define DUK__BI_PRINT(name,x)  duk__bi_print((name),(x))
-+#else
-+#define DUK__BI_PRINT(name,x)
-+#endif
-+
-+/* Current size is about 152 bytes. */
-+typedef struct {
-+	duk_small_int_t n;
-+	duk_uint32_t v[DUK__BI_MAX_PARTS];  /* low to high */
-+} duk__bigint;
-+
-+#ifdef DUK_USE_DDDPRINT
-+DUK_LOCAL void duk__bi_print(const char *name, duk__bigint *x) {
-+	/* Overestimate required size; debug code so not critical to be tight. */
-+	char buf[DUK__BI_MAX_PARTS * 9 + 64];
-+	char *p = buf;
-+	duk_small_int_t i;
-+
-+	/* No NUL term checks in this debug code. */
-+	p += DUK_SPRINTF(p, "%p n=%ld", (void *) x, (long) x->n);
-+	if (x->n == 0) {
-+		p += DUK_SPRINTF(p, " 0");
-+	}
-+	for (i = x->n - 1; i >= 0; i--) {
-+		p += DUK_SPRINTF(p, " %08lx", (unsigned long) x->v[i]);
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("%s: %s", (const char *) name, (const char *) buf));
-+}
-+#endif
-+
-+#ifdef DUK_USE_ASSERTIONS
-+DUK_LOCAL duk_small_int_t duk__bi_is_valid(duk__bigint *x) {
-+	return (duk_small_int_t)
-+	       ( ((x->n >= 0) && (x->n <= DUK__BI_MAX_PARTS)) /* is valid size */ &&
-+	         ((x->n == 0) || (x->v[x->n - 1] != 0)) /* is normalized */ );
-+}
-+#endif
-+
-+DUK_LOCAL void duk__bi_normalize(duk__bigint *x) {
-+	duk_small_int_t i;
-+
-+	for (i = x->n - 1; i >= 0; i--) {
-+		if (x->v[i] != 0) {
-+			break;
-+		}
-+	}
-+
-+	/* Note: if 'x' is zero, x->n becomes 0 here */
-+	x->n = i + 1;
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+
-+/* x <- y */
-+DUK_LOCAL void duk__bi_copy(duk__bigint *x, duk__bigint *y) {
-+	duk_small_int_t n;
-+
-+	n = y->n;
-+	x->n = n;
-+	if (n == 0) {
-+		return;
-+	}
-+	DUK_MEMCPY((void *) x->v, (void *) y->v, (size_t) (sizeof(duk_uint32_t) * n));
-+}
-+
-+DUK_LOCAL void duk__bi_set_small(duk__bigint *x, duk_uint32_t v) {
-+	if (v == 0U) {
-+		x->n = 0;
-+	} else {
-+		x->n = 1;
-+		x->v[0] = v;
-+	}
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+
-+/* Return value: <0  <=>  x < y
-+ *                0  <=>  x == y
-+ *               >0  <=>  x > y
-+ */
-+DUK_LOCAL int duk__bi_compare(duk__bigint *x, duk__bigint *y) {
-+	duk_small_int_t i, nx, ny;
-+	duk_uint32_t tx, ty;
-+
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+
-+	nx = x->n;
-+	ny = y->n;
-+	if (nx > ny) {
-+		goto ret_gt;
-+	}
-+	if (nx < ny) {
-+		goto ret_lt;
-+	}
-+	for (i = nx - 1; i >= 0; i--) {
-+		tx = x->v[i];
-+		ty = y->v[i];
-+
-+		if (tx > ty) {
-+			goto ret_gt;
-+		}
-+		if (tx < ty) {
-+			goto ret_lt;
-+		}
-+	}
-+
-+	return 0;
-+
-+ ret_gt:
-+	return 1;
-+
-+ ret_lt:
-+	return -1;
-+}
-+
-+/* x <- y + z */
-+#ifdef DUK_USE_64BIT_OPS
-+DUK_LOCAL void duk__bi_add(duk__bigint *x, duk__bigint *y, duk__bigint *z) {
-+	duk_uint64_t tmp;
-+	duk_small_int_t i, ny, nz;
-+
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+	DUK_ASSERT(duk__bi_is_valid(z));
-+
-+	if (z->n > y->n) {
-+		duk__bigint *t;
-+		t = y; y = z; z = t;
-+	}
-+	DUK_ASSERT(y->n >= z->n);
-+
-+	ny = y->n; nz = z->n;
-+	tmp = 0U;
-+	for (i = 0; i < ny; i++) {
-+		DUK_ASSERT(i < DUK__BI_MAX_PARTS);
-+		tmp += y->v[i];
-+		if (i < nz) {
-+			tmp += z->v[i];
-+		}
-+		x->v[i] = (duk_uint32_t) (tmp & 0xffffffffUL);
-+		tmp = tmp >> 32;
-+	}
-+	if (tmp != 0U) {
-+		DUK_ASSERT(i < DUK__BI_MAX_PARTS);
-+		x->v[i++] = (duk_uint32_t) tmp;
-+	}
-+	x->n = i;
-+	DUK_ASSERT(x->n <= DUK__BI_MAX_PARTS);
-+
-+	/* no need to normalize */
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+#else  /* DUK_USE_64BIT_OPS */
-+DUK_LOCAL void duk__bi_add(duk__bigint *x, duk__bigint *y, duk__bigint *z) {
-+	duk_uint32_t carry, tmp1, tmp2;
-+	duk_small_int_t i, ny, nz;
-+
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+	DUK_ASSERT(duk__bi_is_valid(z));
-+
-+	if (z->n > y->n) {
-+		duk__bigint *t;
-+		t = y; y = z; z = t;
-+	}
-+	DUK_ASSERT(y->n >= z->n);
-+
-+	ny = y->n; nz = z->n;
-+	carry = 0U;
-+	for (i = 0; i < ny; i++) {
-+		/* Carry is detected based on wrapping which relies on exact 32-bit
-+		 * types.
-+		 */
-+		DUK_ASSERT(i < DUK__BI_MAX_PARTS);
-+		tmp1 = y->v[i];
-+		tmp2 = tmp1;
-+		if (i < nz) {
-+			tmp2 += z->v[i];
-+		}
-+
-+		/* Careful with carry condition:
-+		 *  - If carry not added: 0x12345678 + 0 + 0xffffffff = 0x12345677 (< 0x12345678)
-+		 *  - If carry added:     0x12345678 + 1 + 0xffffffff = 0x12345678 (== 0x12345678)
-+		 */
-+		if (carry) {
-+			tmp2++;
-+			carry = (tmp2 <= tmp1 ? 1U : 0U);
-+		} else {
-+			carry = (tmp2 < tmp1 ? 1U : 0U);
-+		}
-+
-+		x->v[i] = tmp2;
-+	}
-+	if (carry) {
-+		DUK_ASSERT(i < DUK__BI_MAX_PARTS);
-+		DUK_ASSERT(carry == 1U);
-+		x->v[i++] = carry;
-+	}
-+	x->n = i;
-+	DUK_ASSERT(x->n <= DUK__BI_MAX_PARTS);
-+
-+	/* no need to normalize */
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+#endif  /* DUK_USE_64BIT_OPS */
-+
-+/* x <- y + z */
-+DUK_LOCAL void duk__bi_add_small(duk__bigint *x, duk__bigint *y, duk_uint32_t z) {
-+	duk__bigint tmp;
-+
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+
-+	/* XXX: this could be optimized; there is only one call site now though */
-+	duk__bi_set_small(&tmp, z);
-+	duk__bi_add(x, y, &tmp);
-+
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+
-+#if 0  /* unused */
-+/* x <- x + y, use t as temp */
-+DUK_LOCAL void duk__bi_add_copy(duk__bigint *x, duk__bigint *y, duk__bigint *t) {
-+	duk__bi_add(t, x, y);
-+	duk__bi_copy(x, t);
-+}
-+#endif
-+
-+/* x <- y - z, require x >= y => z >= 0, i.e. y >= z */
-+#ifdef DUK_USE_64BIT_OPS
-+DUK_LOCAL void duk__bi_sub(duk__bigint *x, duk__bigint *y, duk__bigint *z) {
-+	duk_small_int_t i, ny, nz;
-+	duk_uint32_t ty, tz;
-+	duk_int64_t tmp;
-+
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+	DUK_ASSERT(duk__bi_is_valid(z));
-+	DUK_ASSERT(duk__bi_compare(y, z) >= 0);
-+	DUK_ASSERT(y->n >= z->n);
-+
-+	ny = y->n; nz = z->n;
-+	tmp = 0;
-+	for (i = 0; i < ny; i++) {
-+		ty = y->v[i];
-+		if (i < nz) {
-+			tz = z->v[i];
-+		} else {
-+			tz = 0;
-+		}
-+		tmp = (duk_int64_t) ty - (duk_int64_t) tz + tmp;
-+		x->v[i] = (duk_uint32_t) (tmp & 0xffffffffUL);
-+		tmp = tmp >> 32;  /* 0 or -1 */
-+	}
-+	DUK_ASSERT(tmp == 0);
-+
-+	x->n = i;
-+	duk__bi_normalize(x);  /* need to normalize, may even cancel to 0 */
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+#else
-+DUK_LOCAL void duk__bi_sub(duk__bigint *x, duk__bigint *y, duk__bigint *z) {
-+	duk_small_int_t i, ny, nz;
-+	duk_uint32_t tmp1, tmp2, borrow;
-+
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+	DUK_ASSERT(duk__bi_is_valid(z));
-+	DUK_ASSERT(duk__bi_compare(y, z) >= 0);
-+	DUK_ASSERT(y->n >= z->n);
-+
-+	ny = y->n; nz = z->n;
-+	borrow = 0U;
-+	for (i = 0; i < ny; i++) {
-+		/* Borrow is detected based on wrapping which relies on exact 32-bit
-+		 * types.
-+		 */
-+		tmp1 = y->v[i];
-+		tmp2 = tmp1;
-+		if (i < nz) {
-+			tmp2 -= z->v[i];
-+		}
-+
-+		/* Careful with borrow condition:
-+		 *  - If borrow not subtracted: 0x12345678 - 0 - 0xffffffff = 0x12345679 (> 0x12345678)
-+		 *  - If borrow subtracted:     0x12345678 - 1 - 0xffffffff = 0x12345678 (== 0x12345678)
-+		 */
-+		if (borrow) {
-+			tmp2--;
-+			borrow = (tmp2 >= tmp1 ? 1U : 0U);
-+		} else {
-+			borrow = (tmp2 > tmp1 ? 1U : 0U);
-+		}
-+
-+		x->v[i] = tmp2;
-+	}
-+	DUK_ASSERT(borrow == 0U);
-+
-+	x->n = i;
-+	duk__bi_normalize(x);  /* need to normalize, may even cancel to 0 */
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+#endif
-+
-+#if 0  /* unused */
-+/* x <- y - z */
-+DUK_LOCAL void duk__bi_sub_small(duk__bigint *x, duk__bigint *y, duk_uint32_t z) {
-+	duk__bigint tmp;
-+
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+
-+	/* XXX: this could be optimized */
-+	duk__bi_set_small(&tmp, z);
-+	duk__bi_sub(x, y, &tmp);
-+
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+#endif
-+
-+/* x <- x - y, use t as temp */
-+DUK_LOCAL void duk__bi_sub_copy(duk__bigint *x, duk__bigint *y, duk__bigint *t) {
-+	duk__bi_sub(t, x, y);
-+	duk__bi_copy(x, t);
-+}
-+
-+/* x <- y * z */
-+DUK_LOCAL void duk__bi_mul(duk__bigint *x, duk__bigint *y, duk__bigint *z) {
-+	duk_small_int_t i, j, nx, nz;
-+
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+	DUK_ASSERT(duk__bi_is_valid(z));
-+
-+	nx = y->n + z->n;  /* max possible */
-+	DUK_ASSERT(nx <= DUK__BI_MAX_PARTS);
-+
-+	if (nx == 0) {
-+		/* Both inputs are zero; cases where only one is zero can go
-+		 * through main algorithm.
-+		 */
-+		x->n = 0;
-+		return;
-+	}
-+
-+	DUK_MEMZERO((void *) x->v, (size_t) (sizeof(duk_uint32_t) * nx));
-+	x->n = nx;
-+
-+	nz = z->n;
-+	for (i = 0; i < y->n; i++) {
-+#ifdef DUK_USE_64BIT_OPS
-+		duk_uint64_t tmp = 0U;
-+		for (j = 0; j < nz; j++) {
-+			tmp += (duk_uint64_t) y->v[i] * (duk_uint64_t) z->v[j] + x->v[i+j];
-+			x->v[i+j] = (duk_uint32_t) (tmp & 0xffffffffUL);
-+			tmp = tmp >> 32;
-+		}
-+		if (tmp > 0) {
-+			DUK_ASSERT(i + j < nx);
-+			DUK_ASSERT(i + j < DUK__BI_MAX_PARTS);
-+			DUK_ASSERT(x->v[i+j] == 0U);
-+			x->v[i+j] = (duk_uint32_t) tmp;
-+		}
-+#else
-+		/*
-+		 *  Multiply + add + carry for 32-bit components using only 16x16->32
-+		 *  multiplies and carry detection based on unsigned overflow.
-+		 *
-+		 *    1st mult, 32-bit: (A*2^16 + B)
-+		 *    2nd mult, 32-bit: (C*2^16 + D)
-+		 *    3rd add, 32-bit: E
-+		 *    4th add, 32-bit: F
-+		 *
-+		 *      (AC*2^16 + B) * (C*2^16 + D) + E + F
-+		 *    = AC*2^32 + AD*2^16 + BC*2^16 + BD + E + F
-+		 *    = AC*2^32 + (AD + BC)*2^16 + (BD + E + F)
-+		 *    = AC*2^32 + AD*2^16 + BC*2^16 + (BD + E + F)
-+		 */
-+		duk_uint32_t a, b, c, d, e, f;
-+		duk_uint32_t r, s, t;
-+
-+		a = y->v[i]; b = a & 0xffffUL; a = a >> 16;
-+
-+		f = 0;
-+		for (j = 0; j < nz; j++) {
-+			c = z->v[j]; d = c & 0xffffUL; c = c >> 16;
-+			e = x->v[i+j];
-+
-+			/* build result as: (r << 32) + s: start with (BD + E + F) */
-+			r = 0;
-+			s = b * d;
-+
-+			/* add E */
-+			t = s + e;
-+			if (t < s) { r++; }  /* carry */
-+			s = t;
-+
-+			/* add F */
-+			t = s + f;
-+			if (t < s) { r++; }  /* carry */
-+			s = t;
-+
-+			/* add BC*2^16 */
-+			t = b * c;
-+			r += (t >> 16);
-+			t = s + ((t & 0xffffUL) << 16);
-+			if (t < s) { r++; }  /* carry */
-+			s = t;
-+
-+			/* add AD*2^16 */
-+			t = a * d;
-+			r += (t >> 16);
-+			t = s + ((t & 0xffffUL) << 16);
-+			if (t < s) { r++; }  /* carry */
-+			s = t;
-+
-+			/* add AC*2^32 */
-+			t = a * c;
-+			r += t;
-+
-+			DUK_DDD(DUK_DDDPRINT("ab=%08lx cd=%08lx ef=%08lx -> rs=%08lx %08lx",
-+			                     (unsigned long) y->v[i], (unsigned long) z->v[j],
-+			                     (unsigned long) x->v[i+j], (unsigned long) r,
-+			                     (unsigned long) s));
-+
-+			x->v[i+j] = s;
-+			f = r;
-+		}
-+		if (f > 0U) {
-+			DUK_ASSERT(i + j < nx);
-+			DUK_ASSERT(i + j < DUK__BI_MAX_PARTS);
-+			DUK_ASSERT(x->v[i+j] == 0U);
-+			x->v[i+j] = (duk_uint32_t) f;
-+		}
-+#endif  /* DUK_USE_64BIT_OPS */
-+	}
-+
-+	duk__bi_normalize(x);
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+
-+/* x <- y * z */
-+DUK_LOCAL void duk__bi_mul_small(duk__bigint *x, duk__bigint *y, duk_uint32_t z) {
-+	duk__bigint tmp;
-+
-+	DUK_ASSERT(duk__bi_is_valid(y));
-+
-+	/* XXX: this could be optimized */
-+	duk__bi_set_small(&tmp, z);
-+	duk__bi_mul(x, y, &tmp);
-+
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+}
-+
-+/* x <- x * y, use t as temp */
-+DUK_LOCAL void duk__bi_mul_copy(duk__bigint *x, duk__bigint *y, duk__bigint *t) {
-+	duk__bi_mul(t, x, y);
-+	duk__bi_copy(x, t);
-+}
-+
-+/* x <- x * y, use t as temp */
-+DUK_LOCAL void duk__bi_mul_small_copy(duk__bigint *x, duk_uint32_t y, duk__bigint *t) {
-+	duk__bi_mul_small(t, x, y);
-+	duk__bi_copy(x, t);
-+}
-+
-+DUK_LOCAL int duk__bi_is_even(duk__bigint *x) {
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+	return (x->n == 0) || ((x->v[0] & 0x01) == 0);
-+}
-+
-+DUK_LOCAL int duk__bi_is_zero(duk__bigint *x) {
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+	return (x->n == 0);  /* this is the case for normalized numbers */
-+}
-+
-+/* Bigint is 2^52.  Used to detect normalized IEEE double mantissa values
-+ * which are at the lowest edge (next floating point value downwards has
-+ * a different exponent).  The lowest mantissa has the form:
-+ *
-+ *     1000........000    (52 zeroes; only "hidden bit" is set)
-+ */
-+DUK_LOCAL duk_small_int_t duk__bi_is_2to52(duk__bigint *x) {
-+	DUK_ASSERT(duk__bi_is_valid(x));
-+	return (duk_small_int_t)
-+	        (x->n == 2) && (x->v[0] == 0U) && (x->v[1] == (1U << (52-32)));
-+}
-+
-+/* x <- (1<<y) */
-+DUK_LOCAL void duk__bi_twoexp(duk__bigint *x, duk_small_int_t y) {
-+	duk_small_int_t n, r;
-+
-+	n = (y / 32) + 1;
-+	DUK_ASSERT(n > 0);
-+	r = y % 32;
-+	DUK_MEMZERO((void *) x->v, sizeof(duk_uint32_t) * n);
-+	x->n = n;
-+	x->v[n - 1] = (((duk_uint32_t) 1) << r);
-+}
-+
-+/* x <- b^y; use t1 and t2 as temps */
-+DUK_LOCAL void duk__bi_exp_small(duk__bigint *x, duk_small_int_t b, duk_small_int_t y, duk__bigint *t1, duk__bigint *t2) {
-+	/* Fast path the binary case */
-+
-+	DUK_ASSERT(x != t1 && x != t2 && t1 != t2);  /* distinct bignums, easy mistake to make */
-+	DUK_ASSERT(b >= 0);
-+	DUK_ASSERT(y >= 0);
-+
-+	if (b == 2) {
-+		duk__bi_twoexp(x, y);
-+		return;
-+	}
-+
-+	/* http://en.wikipedia.org/wiki/Exponentiation_by_squaring */
-+
-+	DUK_DDD(DUK_DDDPRINT("exp_small: b=%ld, y=%ld", (long) b, (long) y));
-+
-+	duk__bi_set_small(x, 1);
-+	duk__bi_set_small(t1, b);
-+	for (;;) {
-+		/* Loop structure ensures that we don't compute t1^2 unnecessarily
-+		 * on the final round, as that might create a bignum exceeding the
-+		 * current DUK__BI_MAX_PARTS limit.
-+		 */
-+		if (y & 0x01) {
-+			duk__bi_mul_copy(x, t1, t2);
-+		}
-+		y = y >> 1;
-+		if (y == 0) {
-+			break;
-+		}
-+		duk__bi_mul_copy(t1, t1, t2);
-+	}
-+
-+	DUK__BI_PRINT("exp_small result", x);
-+}
-+
-+/*
-+ *  A Dragon4 number-to-string variant, based on:
-+ *
-+ *    Guy L. Steele Jr., Jon L. White: "How to Print Floating-Point Numbers
-+ *    Accurately"
-+ *
-+ *    Robert G. Burger, R. Kent Dybvig: "Printing Floating-Point Numbers
-+ *    Quickly and Accurately"
-+ *
-+ *  The current algorithm is based on Figure 1 of the Burger-Dybvig paper,
-+ *  i.e. the base implementation without logarithm estimation speedups
-+ *  (these would increase code footprint considerably).  Fixed-format output
-+ *  does not follow the suggestions in the paper; instead, we generate an
-+ *  extra digit and round-with-carry.
-+ *
-+ *  The same algorithm is used for number parsing (with b=10 and B=2)
-+ *  by generating one extra digit and doing rounding manually.
-+ *
-+ *  See doc/number-conversion.txt for limitations.
-+ */
-+
-+/* Maximum number of digits generated. */
-+#define DUK__MAX_OUTPUT_DIGITS          1040  /* (Number.MAX_VALUE).toString(2).length == 1024, + spare */
-+
-+/* Maximum number of characters in formatted value. */
-+#define DUK__MAX_FORMATTED_LENGTH       1040  /* (-Number.MAX_VALUE).toString(2).length == 1025, + spare */
-+
-+/* Number and (minimum) size of bigints in the nc_ctx structure. */
-+#define DUK__NUMCONV_CTX_NUM_BIGINTS    7
-+#define DUK__NUMCONV_CTX_BIGINTS_SIZE   (sizeof(duk__bigint) * DUK__NUMCONV_CTX_NUM_BIGINTS)
-+
-+typedef struct {
-+	/* Currently about 7*152 = 1064 bytes.  The space for these
-+	 * duk__bigints is used also as a temporary buffer for generating
-+	 * the final string.  This is a bit awkard; a union would be
-+	 * more correct.
-+	 */
-+	duk__bigint f, r, s, mp, mm, t1, t2;
-+
-+	duk_small_int_t is_s2n;        /* if 1, doing a string-to-number; else doing a number-to-string */
-+	duk_small_int_t is_fixed;      /* if 1, doing a fixed format output (not free format) */
-+	duk_small_int_t req_digits;    /* requested number of output digits; 0 = free-format */
-+	duk_small_int_t abs_pos;       /* digit position is absolute, not relative */
-+	duk_small_int_t e;             /* exponent for 'f' */
-+	duk_small_int_t b;             /* input radix */
-+	duk_small_int_t B;             /* output radix */
-+	duk_small_int_t k;             /* see algorithm */
-+	duk_small_int_t low_ok;        /* see algorithm */
-+	duk_small_int_t high_ok;       /* see algorithm */
-+	duk_small_int_t unequal_gaps;  /* m+ != m- (very rarely) */
-+
-+	/* Buffer used for generated digits, values are in the range [0,B-1]. */
-+	duk_uint8_t digits[DUK__MAX_OUTPUT_DIGITS];
-+	duk_small_int_t count;  /* digit count */
-+} duk__numconv_stringify_ctx;
-+
-+/* Note: computes with 'idx' in assertions, so caller beware.
-+ * 'idx' is preincremented, i.e. '1' on first call, because it
-+ * is more convenient for the caller.
-+ */
-+#define DUK__DRAGON4_OUTPUT_PREINC(nc_ctx,preinc_idx,x)  do { \
-+		DUK_ASSERT((preinc_idx) - 1 >= 0); \
-+		DUK_ASSERT((preinc_idx) - 1 < DUK__MAX_OUTPUT_DIGITS); \
-+		((nc_ctx)->digits[(preinc_idx) - 1]) = (duk_uint8_t) (x); \
-+	} while (0)
-+
-+DUK_LOCAL duk_size_t duk__dragon4_format_uint32(duk_uint8_t *buf, duk_uint32_t x, duk_small_int_t radix) {
-+	duk_uint8_t *p;
-+	duk_size_t len;
-+	duk_small_int_t dig;
-+	duk_small_int_t t;
-+
-+	DUK_ASSERT(radix >= 2 && radix <= 36);
-+
-+	/* A 32-bit unsigned integer formats to at most 32 digits (the
-+	 * worst case happens with radix == 2).  Output the digits backwards,
-+	 * and use a memmove() to get them in the right place.
-+	 */
-+
-+	p = buf + 32;
-+	for (;;) {
-+		t = x / radix;
-+		dig = x - t * radix;
-+		x = t;
-+
-+		DUK_ASSERT(dig >= 0 && dig < 36);
-+		*(--p) = DUK__DIGITCHAR(dig);
-+
-+		if (x == 0) {
-+			break;
-+		}
-+	}
-+	len = (duk_size_t) ((buf + 32) - p);
-+
-+	DUK_MEMMOVE((void *) buf, (void *) p, (size_t) len);
-+
-+	return len;
-+}
-+
-+DUK_LOCAL void duk__dragon4_prepare(duk__numconv_stringify_ctx *nc_ctx) {
-+	duk_small_int_t lowest_mantissa;
-+
-+#if 1
-+	/* Assume IEEE round-to-even, so that shorter encoding can be used
-+	 * when round-to-even would produce correct result.  By removing
-+	 * this check (and having low_ok == high_ok == 0) the results would
-+	 * still be accurate but in some cases longer than necessary.
-+	 */
-+	if (duk__bi_is_even(&nc_ctx->f)) {
-+		DUK_DDD(DUK_DDDPRINT("f is even"));
-+		nc_ctx->low_ok = 1;
-+		nc_ctx->high_ok = 1;
-+	} else {
-+		DUK_DDD(DUK_DDDPRINT("f is odd"));
-+		nc_ctx->low_ok = 0;
-+		nc_ctx->high_ok = 0;
-+	}
-+#else
-+	/* Note: not honoring round-to-even should work but now generates incorrect
-+	 * results.  For instance, 1e23 serializes to "a000...", i.e. the first digit
-+	 * equals the radix (10).  Scaling stops one step too early in this case.
-+	 * Don't know why this is the case, but since this code path is unused, it
-+	 * doesn't matter.
-+	 */
-+	nc_ctx->low_ok = 0;
-+	nc_ctx->high_ok = 0;
-+#endif
-+
-+	/* For string-to-number, pretend we never have the lowest mantissa as there
-+	 * is no natural "precision" for inputs.  Having lowest_mantissa == 0, we'll
-+	 * fall into the base cases for both e >= 0 and e < 0.
-+	 */
-+	if (nc_ctx->is_s2n) {
-+		lowest_mantissa = 0;
-+	} else {
-+		lowest_mantissa = duk__bi_is_2to52(&nc_ctx->f);
-+	}
-+
-+	nc_ctx->unequal_gaps = 0;
-+	if (nc_ctx->e >= 0) {
-+		/* exponent non-negative (and thus not minimum exponent) */
-+
-+		if (lowest_mantissa) {
-+			/* (>= e 0) AND (= f (expt b (- p 1)))
-+			 *
-+			 * be <- (expt b e) == b^e
-+			 * be1 <- (* be b) == (expt b (+ e 1)) == b^(e+1)
-+			 * r <- (* f be1 2) == 2 * f * b^(e+1)    [if b==2 -> f * b^(e+2)]
-+			 * s <- (* b 2)                           [if b==2 -> 4]
-+			 * m+ <- be1 == b^(e+1)
-+			 * m- <- be == b^e
-+			 * k <- 0
-+			 * B <- B
-+			 * low_ok <- round
-+			 * high_ok <- round
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("non-negative exponent (not smallest exponent); "
-+			                     "lowest mantissa value for this exponent -> "
-+			                     "unequal gaps"));
-+
-+			duk__bi_exp_small(&nc_ctx->mm, nc_ctx->b, nc_ctx->e, &nc_ctx->t1, &nc_ctx->t2);  /* mm <- b^e */
-+			duk__bi_mul_small(&nc_ctx->mp, &nc_ctx->mm, nc_ctx->b);  /* mp <- b^(e+1) */
-+			duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, 2);
-+			duk__bi_mul(&nc_ctx->r, &nc_ctx->t1, &nc_ctx->mp);       /* r <- (2 * f) * b^(e+1) */
-+			duk__bi_set_small(&nc_ctx->s, nc_ctx->b * 2);            /* s <- 2 * b */
-+			nc_ctx->unequal_gaps = 1;
-+		} else {
-+			/* (>= e 0) AND (not (= f (expt b (- p 1))))
-+			 *
-+			 * be <- (expt b e) == b^e
-+			 * r <- (* f be 2) == 2 * f * b^e    [if b==2 -> f * b^(e+1)]
-+			 * s <- 2
-+			 * m+ <- be == b^e
-+			 * m- <- be == b^e
-+			 * k <- 0
-+			 * B <- B
-+			 * low_ok <- round
-+			 * high_ok <- round
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("non-negative exponent (not smallest exponent); "
-+			                     "not lowest mantissa for this exponent -> "
-+			                     "equal gaps"));
-+
-+			duk__bi_exp_small(&nc_ctx->mm, nc_ctx->b, nc_ctx->e, &nc_ctx->t1, &nc_ctx->t2);  /* mm <- b^e */
-+			duk__bi_copy(&nc_ctx->mp, &nc_ctx->mm);                /* mp <- b^e */
-+			duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, 2);
-+			duk__bi_mul(&nc_ctx->r, &nc_ctx->t1, &nc_ctx->mp);     /* r <- (2 * f) * b^e */
-+			duk__bi_set_small(&nc_ctx->s, 2);                      /* s <- 2 */
-+		}
-+	} else {
-+		/* When doing string-to-number, lowest_mantissa is always 0 so
-+		 * the exponent check, while incorrect, won't matter.
-+		 */
-+		if (nc_ctx->e > DUK__IEEE_DOUBLE_EXP_MIN /*not minimum exponent*/ &&
-+		    lowest_mantissa /* lowest mantissa for this exponent*/) {
-+			/* r <- (* f b 2)                                [if b==2 -> (* f 4)]
-+			 * s <- (* (expt b (- 1 e)) 2) == b^(1-e) * 2    [if b==2 -> b^(2-e)]
-+			 * m+ <- b == 2
-+			 * m- <- 1
-+			 * k <- 0
-+			 * B <- B
-+			 * low_ok <- round
-+			 * high_ok <- round
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("negative exponent; not minimum exponent and "
-+			                     "lowest mantissa for this exponent -> "
-+			                     "unequal gaps"));
-+
-+			duk__bi_mul_small(&nc_ctx->r, &nc_ctx->f, nc_ctx->b * 2);  /* r <- (2 * b) * f */
-+			duk__bi_exp_small(&nc_ctx->t1, nc_ctx->b, 1 - nc_ctx->e, &nc_ctx->s, &nc_ctx->t2);  /* NB: use 's' as temp on purpose */
-+			duk__bi_mul_small(&nc_ctx->s, &nc_ctx->t1, 2);             /* s <- b^(1-e) * 2 */
-+			duk__bi_set_small(&nc_ctx->mp, 2);
-+			duk__bi_set_small(&nc_ctx->mm, 1);
-+			nc_ctx->unequal_gaps = 1;
-+		} else {
-+			/* r <- (* f 2)
-+			 * s <- (* (expt b (- e)) 2) == b^(-e) * 2    [if b==2 -> b^(1-e)]
-+			 * m+ <- 1
-+			 * m- <- 1
-+			 * k <- 0
-+			 * B <- B
-+			 * low_ok <- round
-+			 * high_ok <- round
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("negative exponent; minimum exponent or not "
-+			                     "lowest mantissa for this exponent -> "
-+			                     "equal gaps"));
-+
-+			duk__bi_mul_small(&nc_ctx->r, &nc_ctx->f, 2);            /* r <- 2 * f */
-+			duk__bi_exp_small(&nc_ctx->t1, nc_ctx->b, -nc_ctx->e, &nc_ctx->s, &nc_ctx->t2);  /* NB: use 's' as temp on purpose */
-+			duk__bi_mul_small(&nc_ctx->s, &nc_ctx->t1, 2);           /* s <- b^(-e) * 2 */
-+			duk__bi_set_small(&nc_ctx->mp, 1);
-+			duk__bi_set_small(&nc_ctx->mm, 1);
-+		}
-+	}
-+}
-+
-+DUK_LOCAL void duk__dragon4_scale(duk__numconv_stringify_ctx *nc_ctx) {
-+	duk_small_int_t k = 0;
-+
-+	/* This is essentially the 'scale' algorithm, with recursion removed.
-+	 * Note that 'k' is either correct immediately, or will move in one
-+	 * direction in the loop.  There's no need to do the low/high checks
-+	 * on every round (like the Scheme algorithm does).
-+	 *
-+	 * The scheme algorithm finds 'k' and updates 's' simultaneously,
-+	 * while the logical algorithm finds 'k' with 's' having its initial
-+	 * value, after which 's' is updated separately (see the Burger-Dybvig
-+	 * paper, Section 3.1, steps 2 and 3).
-+	 *
-+	 * The case where m+ == m- (almost always) is optimized for, because
-+	 * it reduces the bigint operations considerably and almost always
-+	 * applies.  The scale loop only needs to work with m+, so this works.
-+	 */
-+
-+	/* XXX: this algorithm could be optimized quite a lot by using e.g.
-+	 * a logarithm based estimator for 'k' and performing B^n multiplication
-+	 * using a lookup table or using some bit-representation based exp
-+	 * algorithm.  Currently we just loop, with significant performance
-+	 * impact for very large and very small numbers.
-+	 */
-+
-+	DUK_DDD(DUK_DDDPRINT("scale: B=%ld, low_ok=%ld, high_ok=%ld",
-+	                     (long) nc_ctx->B, (long) nc_ctx->low_ok, (long) nc_ctx->high_ok));
-+	DUK__BI_PRINT("r(init)", &nc_ctx->r);
-+	DUK__BI_PRINT("s(init)", &nc_ctx->s);
-+	DUK__BI_PRINT("mp(init)", &nc_ctx->mp);
-+	DUK__BI_PRINT("mm(init)", &nc_ctx->mm);
-+
-+	for (;;) {
-+		DUK_DDD(DUK_DDDPRINT("scale loop (inc k), k=%ld", (long) k));
-+		DUK__BI_PRINT("r", &nc_ctx->r);
-+		DUK__BI_PRINT("s", &nc_ctx->s);
-+		DUK__BI_PRINT("m+", &nc_ctx->mp);
-+		DUK__BI_PRINT("m-", &nc_ctx->mm);
-+
-+		duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp);  /* t1 = (+ r m+) */
-+		if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (nc_ctx->high_ok ? 0 : 1)) {
-+			DUK_DDD(DUK_DDDPRINT("k is too low"));
-+			/* r <- r
-+			 * s <- (* s B)
-+			 * m+ <- m+
-+			 * m- <- m-
-+			 * k <- (+ k 1)
-+			 */
-+
-+			duk__bi_mul_small_copy(&nc_ctx->s, nc_ctx->B, &nc_ctx->t1);
-+			k++;
-+		} else {
-+			break;
-+		}
-+	}
-+
-+	/* k > 0 -> k was too low, and cannot be too high */
-+	if (k > 0) {
-+		goto skip_dec_k;
-+	}
-+
-+	for (;;) {
-+		DUK_DDD(DUK_DDDPRINT("scale loop (dec k), k=%ld", (long) k));
-+		DUK__BI_PRINT("r", &nc_ctx->r);
-+		DUK__BI_PRINT("s", &nc_ctx->s);
-+		DUK__BI_PRINT("m+", &nc_ctx->mp);
-+		DUK__BI_PRINT("m-", &nc_ctx->mm);
-+
-+		duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp);  /* t1 = (+ r m+) */
-+		duk__bi_mul_small(&nc_ctx->t2, &nc_ctx->t1, nc_ctx->B);   /* t2 = (* (+ r m+) B) */
-+		if (duk__bi_compare(&nc_ctx->t2, &nc_ctx->s) <= (nc_ctx->high_ok ? -1 : 0)) {
-+			DUK_DDD(DUK_DDDPRINT("k is too high"));
-+			/* r <- (* r B)
-+			 * s <- s
-+			 * m+ <- (* m+ B)
-+			 * m- <- (* m- B)
-+			 * k <- (- k 1)
-+			 */
-+			duk__bi_mul_small_copy(&nc_ctx->r, nc_ctx->B, &nc_ctx->t1);
-+			duk__bi_mul_small_copy(&nc_ctx->mp, nc_ctx->B, &nc_ctx->t1);
-+			if (nc_ctx->unequal_gaps) {
-+				DUK_DDD(DUK_DDDPRINT("m+ != m- -> need to update m- too"));
-+				duk__bi_mul_small_copy(&nc_ctx->mm, nc_ctx->B, &nc_ctx->t1);
-+			}
-+			k--;
-+		} else {
-+			break;
-+		}
-+	}
-+
-+ skip_dec_k:
-+
-+	if (!nc_ctx->unequal_gaps) {
-+		DUK_DDD(DUK_DDDPRINT("equal gaps, copy m- from m+"));
-+		duk__bi_copy(&nc_ctx->mm, &nc_ctx->mp);  /* mm <- mp */
-+	}
-+	nc_ctx->k = k;
-+
-+	DUK_DDD(DUK_DDDPRINT("final k: %ld", (long) k));
-+	DUK__BI_PRINT("r(final)", &nc_ctx->r);
-+	DUK__BI_PRINT("s(final)", &nc_ctx->s);
-+	DUK__BI_PRINT("mp(final)", &nc_ctx->mp);
-+	DUK__BI_PRINT("mm(final)", &nc_ctx->mm);
-+}
-+
-+DUK_LOCAL void duk__dragon4_generate(duk__numconv_stringify_ctx *nc_ctx) {
-+	duk_small_int_t tc1, tc2;    /* terminating conditions */
-+	duk_small_int_t d;           /* current digit */
-+	duk_small_int_t count = 0;   /* digit count */
-+
-+	/*
-+	 *  Digit generation loop.
-+	 *
-+	 *  Different termination conditions:
-+	 *
-+	 *    1. Free format output.  Terminate when shortest accurate
-+	 *       representation found.
-+	 *
-+	 *    2. Fixed format output, with specific number of digits.
-+	 *       Ignore termination conditions, terminate when digits
-+	 *       generated.  Caller requests an extra digit and rounds.
-+	 *
-+	 *    3. Fixed format output, with a specific absolute cut-off
-+	 *       position (e.g. 10 digits after decimal point).  Note
-+	 *       that we always generate at least one digit, even if
-+	 *       the digit is below the cut-off point already.
-+	 */
-+
-+	for (;;) {
-+		DUK_DDD(DUK_DDDPRINT("generate loop, count=%ld, k=%ld, B=%ld, low_ok=%ld, high_ok=%ld",
-+		                     (long) count, (long) nc_ctx->k, (long) nc_ctx->B,
-+		                     (long) nc_ctx->low_ok, (long) nc_ctx->high_ok));
-+		DUK__BI_PRINT("r", &nc_ctx->r);
-+		DUK__BI_PRINT("s", &nc_ctx->s);
-+		DUK__BI_PRINT("m+", &nc_ctx->mp);
-+		DUK__BI_PRINT("m-", &nc_ctx->mm);
-+
-+		/* (quotient-remainder (* r B) s) using a dummy subtraction loop */
-+		duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->r, nc_ctx->B);       /* t1 <- (* r B) */
-+		d = 0;
-+		for (;;) {
-+			if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) < 0) {
-+				break;
-+			}
-+			duk__bi_sub_copy(&nc_ctx->t1, &nc_ctx->s, &nc_ctx->t2);  /* t1 <- t1 - s */
-+			d++;
-+		}
-+		duk__bi_copy(&nc_ctx->r, &nc_ctx->t1);  /* r <- (remainder (* r B) s) */
-+		                                        /* d <- (quotient (* r B) s)   (in range 0...B-1) */
-+		DUK_DDD(DUK_DDDPRINT("-> d(quot)=%ld", (long) d));
-+		DUK__BI_PRINT("r(rem)", &nc_ctx->r);
-+
-+		duk__bi_mul_small_copy(&nc_ctx->mp, nc_ctx->B, &nc_ctx->t2); /* m+ <- (* m+ B) */
-+		duk__bi_mul_small_copy(&nc_ctx->mm, nc_ctx->B, &nc_ctx->t2); /* m- <- (* m- B) */
-+		DUK__BI_PRINT("mp(upd)", &nc_ctx->mp);
-+		DUK__BI_PRINT("mm(upd)", &nc_ctx->mm);
-+
-+		/* Terminating conditions.  For fixed width output, we just ignore the
-+		 * terminating conditions (and pretend that tc1 == tc2 == false).  The
-+		 * the current shortcut for fixed-format output is to generate a few
-+		 * extra digits and use rounding (with carry) to finish the output.
-+		 */
-+
-+		if (nc_ctx->is_fixed == 0) {
-+			/* free-form */
-+			tc1 = (duk__bi_compare(&nc_ctx->r, &nc_ctx->mm) <= (nc_ctx->low_ok ? 0 : -1));
-+
-+			duk__bi_add(&nc_ctx->t1, &nc_ctx->r, &nc_ctx->mp);  /* t1 <- (+ r m+) */
-+			tc2 = (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) >= (&nc_ctx->high_ok ? 0 : 1));
-+
-+			DUK_DDD(DUK_DDDPRINT("tc1=%ld, tc2=%ld", (long) tc1, (long) tc2));
-+		} else {
-+			/* fixed-format */
-+			tc1 = 0;
-+			tc2 = 0;
-+		}
-+
-+		/* Count is incremented before DUK__DRAGON4_OUTPUT_PREINC() call
-+		 * on purpose, which is taken into account by the macro.
-+		 */
-+		count++;
-+
-+		if (tc1) {
-+			if (tc2) {
-+				/* tc1 = true, tc2 = true */
-+				duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->r, 2);
-+				if (duk__bi_compare(&nc_ctx->t1, &nc_ctx->s) < 0) {  /* (< (* r 2) s) */
-+					DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=true, 2r > s: output d --> %ld (k=%ld)",
-+					                     (long) d, (long) nc_ctx->k));
-+					DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
-+				} else {
-+					DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=true, 2r <= s: output d+1 --> %ld (k=%ld)",
-+					                     (long) (d + 1), (long) nc_ctx->k));
-+					DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d + 1);
-+				}
-+				break;
-+			} else {
-+				/* tc1 = true, tc2 = false */
-+				DUK_DDD(DUK_DDDPRINT("tc1=true, tc2=false: output d --> %ld (k=%ld)",
-+				                     (long) d, (long) nc_ctx->k));
-+				DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
-+				break;
-+			}
-+		} else {
-+			if (tc2) {
-+				/* tc1 = false, tc2 = true */
-+				DUK_DDD(DUK_DDDPRINT("tc1=false, tc2=true: output d+1 --> %ld (k=%ld)",
-+				                     (long) (d + 1), (long) nc_ctx->k));
-+				DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d + 1);
-+				break;
-+			} else {
-+				/* tc1 = false, tc2 = false */
-+				DUK_DDD(DUK_DDDPRINT("tc1=false, tc2=false: output d --> %ld (k=%ld)",
-+				                     (long) d, (long) nc_ctx->k));
-+				DUK__DRAGON4_OUTPUT_PREINC(nc_ctx, count, d);
-+
-+				/* r <- r    (updated above: r <- (remainder (* r B) s)
-+				 * s <- s
-+				 * m+ <- m+  (updated above: m+ <- (* m+ B)
-+				 * m- <- m-  (updated above: m- <- (* m- B)
-+				 * B, low_ok, high_ok are fixed
-+				 */
-+
-+				/* fall through and continue for-loop */
-+			}
-+		}
-+
-+		/* fixed-format termination conditions */
-+		if (nc_ctx->is_fixed) {
-+			if (nc_ctx->abs_pos) {
-+				int pos = nc_ctx->k - count + 1;  /* count is already incremented, take into account */
-+				DUK_DDD(DUK_DDDPRINT("fixed format, absolute: abs pos=%ld, k=%ld, count=%ld, req=%ld",
-+				                     (long) pos, (long) nc_ctx->k, (long) count, (long) nc_ctx->req_digits));
-+				if (pos <= nc_ctx->req_digits) {
-+					DUK_DDD(DUK_DDDPRINT("digit position reached req_digits, end generate loop"));
-+					break;
-+				}
-+			} else {
-+				DUK_DDD(DUK_DDDPRINT("fixed format, relative: k=%ld, count=%ld, req=%ld",
-+				                     (long) nc_ctx->k, (long) count, (long) nc_ctx->req_digits));
-+				if (count >= nc_ctx->req_digits) {
-+					DUK_DDD(DUK_DDDPRINT("digit count reached req_digits, end generate loop"));
-+					break;
-+				}
-+			}
-+		}
-+	}  /* for */
-+
-+	nc_ctx->count = count;
-+
-+	DUK_DDD(DUK_DDDPRINT("generate finished"));
-+
-+#ifdef DUK_USE_DDDPRINT
-+	{
-+		duk_uint8_t buf[2048];
-+		duk_small_int_t i, t;
-+		DUK_MEMZERO(buf, sizeof(buf));
-+		for (i = 0; i < nc_ctx->count; i++) {
-+			t = nc_ctx->digits[i];
-+			if (t < 0 || t > 36) {
-+				buf[i] = (duk_uint8_t) '?';
-+			} else {
-+				buf[i] = (duk_uint8_t) DUK__DIGITCHAR(t);
-+			}
-+		}
-+		DUK_DDD(DUK_DDDPRINT("-> generated digits; k=%ld, digits='%s'",
-+		                     (long) nc_ctx->k, (const char *) buf));
-+	}
-+#endif
-+}
-+
-+/* Round up digits to a given position.  If position is out-of-bounds,
-+ * does nothing.  If carry propagates over the first digit, a '1' is
-+ * prepended to digits and 'k' will be updated.  Return value indicates
-+ * whether carry propagated over the first digit.
-+ *
-+ * Note that nc_ctx->count is NOT updated based on the rounding position
-+ * (it is updated only if carry overflows over the first digit and an
-+ * extra digit is prepended).
-+ */
-+DUK_LOCAL duk_small_int_t duk__dragon4_fixed_format_round(duk__numconv_stringify_ctx *nc_ctx, duk_small_int_t round_idx) {
-+	duk_small_int_t t;
-+	duk_uint8_t *p;
-+	duk_uint8_t roundup_limit;
-+	duk_small_int_t ret = 0;
-+
-+	/*
-+	 *  round_idx points to the digit which is considered for rounding; the
-+	 *  digit to its left is the final digit of the rounded value.  If round_idx
-+	 *  is zero, rounding will be performed; the result will either be an empty
-+	 *  rounded value or if carry happens a '1' digit is generated.
-+	 */
-+
-+	if (round_idx >= nc_ctx->count) {
-+		DUK_DDD(DUK_DDDPRINT("round_idx out of bounds (%ld >= %ld (count)) -> no rounding",
-+		                     (long) round_idx, (long) nc_ctx->count));
-+		return 0;
-+	} else if (round_idx < 0) {
-+		DUK_DDD(DUK_DDDPRINT("round_idx out of bounds (%ld < 0) -> no rounding",
-+		                     (long) round_idx));
-+		return 0;
-+	}
-+
-+	/*
-+	 *  Round-up limit.
-+	 *
-+	 *  For even values, divides evenly, e.g. 10 -> roundup_limit=5.
-+	 *
-+	 *  For odd values, rounds up, e.g. 3 -> roundup_limit=2.
-+	 *  If radix is 3, 0/3 -> down, 1/3 -> down, 2/3 -> up.
-+	 */
-+	roundup_limit = (duk_uint8_t) ((nc_ctx->B + 1) / 2);
-+
-+	p = &nc_ctx->digits[round_idx];
-+	if (*p >= roundup_limit) {
-+		DUK_DDD(DUK_DDDPRINT("fixed-format rounding carry required"));
-+		/* carry */
-+		for (;;) {
-+			*p = 0;
-+			if (p == &nc_ctx->digits[0]) {
-+				DUK_DDD(DUK_DDDPRINT("carry propagated to first digit -> special case handling"));
-+				DUK_MEMMOVE((void *) (&nc_ctx->digits[1]),
-+				            (void *) (&nc_ctx->digits[0]),
-+				            (size_t) (sizeof(char) * nc_ctx->count));
-+				nc_ctx->digits[0] = 1;  /* don't increase 'count' */
-+				nc_ctx->k++;  /* position of highest digit changed */
-+				nc_ctx->count++;  /* number of digits changed */
-+				ret = 1;
-+				break;
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("fixed-format rounding carry: B=%ld, roundup_limit=%ld, p=%p, digits=%p",
-+			                     (long) nc_ctx->B, (long) roundup_limit, (void *) p, (void *) nc_ctx->digits));
-+			p--;
-+			t = *p;
-+			DUK_DDD(DUK_DDDPRINT("digit before carry: %ld", (long) t));
-+			if (++t < nc_ctx->B) {
-+				DUK_DDD(DUK_DDDPRINT("rounding carry terminated"));
-+				*p = t;
-+				break;
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("wraps, carry to next digit"));
-+		}
-+	}
-+
-+	return ret;
-+}
-+
-+#define DUK__NO_EXP  (65536)  /* arbitrary marker, outside valid exp range */
-+
-+DUK_LOCAL void duk__dragon4_convert_and_push(duk__numconv_stringify_ctx *nc_ctx,
-+                                          duk_context *ctx,
-+                                          duk_small_int_t radix,
-+                                          duk_small_int_t digits,
-+                                          duk_small_uint_t flags,
-+                                          duk_small_int_t neg) {
-+	duk_small_int_t k;
-+	duk_small_int_t pos, pos_end;
-+	duk_small_int_t expt;
-+	duk_small_int_t dig;
-+	duk_uint8_t *q;
-+	duk_uint8_t *buf;
-+
-+	/*
-+	 *  The string conversion here incorporates all the necessary Ecmascript
-+	 *  semantics without attempting to be generic.  nc_ctx->digits contains
-+	 *  nc_ctx->count digits (>= 1), with the topmost digit's 'position'
-+	 *  indicated by nc_ctx->k as follows:
-+	 *
-+	 *    digits="123" count=3 k=0   -->   0.123
-+	 *    digits="123" count=3 k=1   -->   1.23
-+	 *    digits="123" count=3 k=5   -->   12300
-+	 *    digits="123" count=3 k=-1  -->   0.0123
-+	 *
-+	 *  Note that the identifier names used for format selection are different
-+	 *  in Burger-Dybvig paper and Ecmascript specification (quite confusingly
-+	 *  so, because e.g. 'k' has a totally different meaning in each).  See
-+	 *  documentation for discussion.
-+	 *
-+	 *  Ecmascript doesn't specify any specific behavior for format selection
-+	 *  (e.g. when to use exponent notation) for non-base-10 numbers.
-+	 *
-+	 *  The bigint space in the context is reused for string output, as there
-+	 *  is more than enough space for that (>1kB at the moment), and we avoid
-+	 *  allocating even more stack.
-+	 */
-+
-+	DUK_ASSERT(DUK__NUMCONV_CTX_BIGINTS_SIZE >= DUK__MAX_FORMATTED_LENGTH);
-+	DUK_ASSERT(nc_ctx->count >= 1);
-+
-+	k = nc_ctx->k;
-+	buf = (duk_uint8_t *) &nc_ctx->f;  /* XXX: union would be more correct */
-+	q = buf;
-+
-+	/* Exponent handling: if exponent format is used, record exponent value and
-+	 * fake k such that one leading digit is generated (e.g. digits=123 -> "1.23").
-+	 *
-+	 * toFixed() prevents exponent use; otherwise apply a set of criteria to
-+	 * match the other API calls (toString(), toPrecision, etc).
-+	 */
-+
-+	expt = DUK__NO_EXP;
-+	if (!nc_ctx->abs_pos /* toFixed() */) {
-+		if ((flags & DUK_N2S_FLAG_FORCE_EXP) ||             /* exponential notation forced */
-+		    ((flags & DUK_N2S_FLAG_NO_ZERO_PAD) &&          /* fixed precision and zero padding would be required */
-+	             (k - digits >= 1)) ||                          /* (e.g. k=3, digits=2 -> "12X") */
-+		    ((k > 21 || k <= -6) && (radix == 10))) {       /* toString() conditions */
-+			DUK_DDD(DUK_DDDPRINT("use exponential notation: k=%ld -> expt=%ld",
-+			                     (long) k, (long) (k - 1)));
-+			expt = k - 1;  /* e.g. 12.3 -> digits="123" k=2 -> 1.23e1 */
-+			k = 1;  /* generate mantissa with a single leading whole number digit */
-+		}
-+	}
-+
-+	if (neg) {
-+		*q++ = '-';
-+	}
-+
-+	/* Start position (inclusive) and end position (exclusive) */
-+	pos = (k >= 1 ? k : 1);
-+	if (nc_ctx->is_fixed) {
-+		if (nc_ctx->abs_pos) {
-+			/* toFixed() */
-+			pos_end = -digits;
-+		} else {
-+			pos_end = k - digits;
-+		}
-+	} else {
-+		pos_end = k - nc_ctx->count;
-+	}
-+	if (pos_end > 0) {
-+		pos_end = 0;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("expt=%ld, k=%ld, count=%ld, pos=%ld, pos_end=%ld, is_fixed=%ld, "
-+	                     "digits=%ld, abs_pos=%ld",
-+	                     (long) expt, (long) k, (long) nc_ctx->count, (long) pos, (long) pos_end,
-+	                     (long) nc_ctx->is_fixed, (long) digits, (long) nc_ctx->abs_pos));
-+
-+	/* Digit generation */
-+	while (pos > pos_end) {
-+		DUK_DDD(DUK_DDDPRINT("digit generation: pos=%ld, pos_end=%ld",
-+		                     (long) pos, (long) pos_end));
-+		if (pos == 0) {
-+			*q++ = (duk_uint8_t) '.';
-+		}
-+		if (pos > k) {
-+			*q++ = (duk_uint8_t) '0';
-+		} else if (pos <= k - nc_ctx->count) {
-+			*q++ = (duk_uint8_t) '0';
-+		} else {
-+			dig = nc_ctx->digits[k - pos];
-+			DUK_ASSERT(dig >= 0 && dig < nc_ctx->B);
-+			*q++ = (duk_uint8_t) DUK__DIGITCHAR(dig);
-+		}
-+
-+		pos--;
-+	}
-+	DUK_ASSERT(pos <= 1);
-+
-+	/* Exponent */
-+	if (expt != DUK__NO_EXP) {
-+		/*
-+		 *  Exponent notation for non-base-10 numbers isn't specified in Ecmascript
-+		 *  specification, as it never explicitly turns up: non-decimal numbers can
-+		 *  only be formatted with Number.prototype.toString([radix]) and for that,
-+		 *  behavior is not explicitly specified.
-+		 *
-+		 *  Logical choices include formatting the exponent as decimal (e.g. binary
-+		 *  100000 as 1e+5) or in current radix (e.g. binary 100000 as 1e+101).
-+		 *  The Dragon4 algorithm (in the original paper) prints the exponent value
-+		 *  in the target radix B.  However, for radix values 15 and above, the
-+		 *  exponent separator 'e' is no longer easily parseable.  Consider, for
-+		 *  instance, the number "1.faecee+1c".
-+		 */
-+
-+		duk_size_t len;
-+		char expt_sign;
-+
-+		*q++ = 'e';
-+		if (expt >= 0) {
-+			expt_sign = '+';
-+		} else {
-+			expt_sign = '-';
-+			expt = -expt;
-+		}
-+		*q++ = (duk_uint8_t) expt_sign;
-+		len = duk__dragon4_format_uint32(q, (duk_uint32_t) expt, radix);
-+		q += len;
-+	}
-+
-+	duk_push_lstring(ctx, (const char *) buf, (size_t) (q - buf));
-+}
-+
-+/*
-+ *  Conversion helpers
-+ */
-+
-+DUK_LOCAL void duk__dragon4_double_to_ctx(duk__numconv_stringify_ctx *nc_ctx, duk_double_t x) {
-+	duk_double_union u;
-+	duk_uint32_t tmp;
-+	duk_small_int_t expt;
-+
-+	/*
-+	 *    seeeeeee eeeeffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff
-+	 *       A        B        C        D        E        F        G        H
-+	 *
-+	 *    s       sign bit
-+	 *    eee...  exponent field
-+	 *    fff...  fraction
-+	 *
-+	 *    ieee value = 1.ffff... * 2^(e - 1023)  (normal)
-+	 *               = 0.ffff... * 2^(-1022)     (denormal)
-+	 *
-+	 *    algorithm v = f * b^e
-+	 */
-+
-+	DUK_DBLUNION_SET_DOUBLE(&u, x);
-+
-+	nc_ctx->f.n = 2;
-+
-+	tmp = DUK_DBLUNION_GET_LOW32(&u);
-+	nc_ctx->f.v[0] = tmp;
-+	tmp = DUK_DBLUNION_GET_HIGH32(&u);
-+	nc_ctx->f.v[1] = tmp & 0x000fffffUL;
-+	expt = (duk_small_int_t) ((tmp >> 20) & 0x07ffUL);
-+
-+	if (expt == 0) {
-+		/* denormal */
-+		expt = DUK__IEEE_DOUBLE_EXP_MIN - 52;
-+		duk__bi_normalize(&nc_ctx->f);
-+	} else {
-+		/* normal: implicit leading 1-bit */
-+		nc_ctx->f.v[1] |= 0x00100000UL;
-+		expt = expt - DUK__IEEE_DOUBLE_EXP_BIAS - 52;
-+		DUK_ASSERT(duk__bi_is_valid(&nc_ctx->f));  /* true, because v[1] has at least one bit set */
-+	}
-+
-+	DUK_ASSERT(duk__bi_is_valid(&nc_ctx->f));
-+
-+	nc_ctx->e = expt;
-+}
-+
-+DUK_LOCAL void duk__dragon4_ctx_to_double(duk__numconv_stringify_ctx *nc_ctx, duk_double_t *x) {
-+	duk_double_union u;
-+	duk_small_int_t expt;
-+	duk_small_int_t i;
-+	duk_small_int_t bitstart;
-+	duk_small_int_t bitround;
-+	duk_small_int_t bitidx;
-+	duk_small_int_t skip_round;
-+	duk_uint32_t t, v;
-+
-+	DUK_ASSERT(nc_ctx->count == 53 + 1);
-+
-+	/* Sometimes this assert is not true right now; it will be true after
-+	 * rounding.  See: test-bug-numconv-mantissa-assert.js.
-+	 */
-+	DUK_ASSERT_DISABLE(nc_ctx->digits[0] == 1);  /* zero handled by caller */
-+
-+	/* Should not be required because the code below always sets both high
-+	 * and low parts, but at least gcc-4.4.5 fails to deduce this correctly
-+	 * (perhaps because the low part is set (seemingly) conditionally in a
-+	 * loop), so this is here to avoid the bogus warning.
-+	 */
-+	DUK_MEMZERO((void *) &u, sizeof(u));
-+
-+	/*
-+	 *  Figure out how generated digits match up with the mantissa,
-+	 *  and then perform rounding.  If mantissa overflows, need to
-+	 *  recompute the exponent (it is bumped and may overflow to
-+	 *  infinity).
-+	 *
-+	 *  For normal numbers the leading '1' is hidden and ignored,
-+	 *  and the last bit is used for rounding:
-+	 *
-+	 *                          rounding pt
-+	 *       <--------52------->|
-+	 *     1 x x x x ... x x x x|y  ==>  x x x x ... x x x x
-+	 *
-+	 *  For denormals, the leading '1' is included in the number,
-+	 *  and the rounding point is different:
-+	 *
-+	 *                      rounding pt
-+	 *     <--52 or less--->|
-+	 *     1 x x x x ... x x|x x y  ==>  0 0 ... 1 x x ... x x
-+	 *
-+	 *  The largest denormals will have a mantissa beginning with
-+	 *  a '1' (the explicit leading bit); smaller denormals will
-+	 *  have leading zero bits.
-+	 *
-+	 *  If the exponent would become too high, the result becomes
-+	 *  Infinity.  If the exponent is so small that the entire
-+	 *  mantissa becomes zero, the result becomes zero.
-+	 *
-+	 *  Note: the Dragon4 'k' is off-by-one with respect to the IEEE
-+	 *  exponent.  For instance, k==0 indicates that the leading '1'
-+	 *  digit is at the first binary fraction position (0.1xxx...);
-+	 *  the corresponding IEEE exponent would be -1.
-+	 */
-+
-+	skip_round = 0;
-+
-+ recheck_exp:
-+
-+	expt = nc_ctx->k - 1;   /* IEEE exp without bias */
-+	if (expt > 1023) {
-+		/* Infinity */
-+		bitstart = -255;  /* needed for inf: causes mantissa to become zero,
-+		                   * and rounding to be skipped.
-+		                   */
-+		expt = 2047;
-+	} else if (expt >= -1022) {
-+		/* normal */
-+		bitstart = 1;  /* skip leading digit */
-+		expt += DUK__IEEE_DOUBLE_EXP_BIAS;
-+		DUK_ASSERT(expt >= 1 && expt <= 2046);
-+	} else {
-+		/* denormal or zero */
-+		bitstart = 1023 + expt;  /* expt==-1023 -> bitstart=0 (leading 1);
-+		                          * expt==-1024 -> bitstart=-1 (one left of leading 1), etc
-+		                          */
-+		expt = 0;
-+	}
-+	bitround = bitstart + 52;
-+
-+	DUK_DDD(DUK_DDDPRINT("ieee expt=%ld, bitstart=%ld, bitround=%ld",
-+	                     (long) expt, (long) bitstart, (long) bitround));
-+
-+	if (!skip_round) {
-+		if (duk__dragon4_fixed_format_round(nc_ctx, bitround)) {
-+			/* Corner case: see test-numconv-parse-mant-carry.js.  We could
-+			 * just bump the exponent and update bitstart, but it's more robust
-+			 * to recompute (but avoid rounding twice).
-+			 */
-+			DUK_DDD(DUK_DDDPRINT("rounding caused exponent to be bumped, recheck exponent"));
-+			skip_round = 1;
-+			goto recheck_exp;
-+		}
-+	}
-+
-+	/*
-+	 *  Create mantissa
-+	 */
-+
-+	t = 0;
-+	for (i = 0; i < 52; i++) {
-+		bitidx = bitstart + 52 - 1 - i;
-+		if (bitidx >= nc_ctx->count) {
-+			v = 0;
-+		} else if (bitidx < 0) {
-+			v = 0;
-+		} else {
-+			v = nc_ctx->digits[bitidx];
-+		}
-+		DUK_ASSERT(v == 0 || v == 1);
-+		t += v << (i % 32);
-+		if (i == 31) {
-+			/* low 32 bits is complete */
-+			DUK_DBLUNION_SET_LOW32(&u, t);
-+			t = 0;
-+		}
-+	}
-+	/* t has high mantissa */
-+
-+	DUK_DDD(DUK_DDDPRINT("mantissa is complete: %08lx %08lx",
-+	                     (unsigned long) t,
-+	                     (unsigned long) DUK_DBLUNION_GET_LOW32(&u)));
-+
-+	DUK_ASSERT(expt >= 0 && expt <= 0x7ffL);
-+	t += expt << 20;
-+#if 0  /* caller handles sign change */
-+	if (negative) {
-+		t |= 0x80000000U;
-+	}
-+#endif
-+	DUK_DBLUNION_SET_HIGH32(&u, t);
-+
-+	DUK_DDD(DUK_DDDPRINT("number is complete: %08lx %08lx",
-+	                     (unsigned long) DUK_DBLUNION_GET_HIGH32(&u),
-+	                     (unsigned long) DUK_DBLUNION_GET_LOW32(&u)));
-+
-+	*x = DUK_DBLUNION_GET_DOUBLE(&u);
-+}
-+
-+/*
-+ *  Exposed number-to-string API
-+ *
-+ *  Input: [ number ]
-+ *  Output: [ string ]
-+ */
-+
-+DUK_INTERNAL void duk_numconv_stringify(duk_context *ctx, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags) {
-+	duk_double_t x;
-+	duk_small_int_t c;
-+	duk_small_int_t neg;
-+	duk_uint32_t uval;
-+	duk__numconv_stringify_ctx nc_ctx_alloc;  /* large context; around 2kB now */
-+	duk__numconv_stringify_ctx *nc_ctx = &nc_ctx_alloc;
-+
-+	x = (duk_double_t) duk_require_number(ctx, -1);
-+	duk_pop(ctx);
-+
-+	/*
-+	 *  Handle special cases (NaN, infinity, zero).
-+	 */
-+
-+	c = (duk_small_int_t) DUK_FPCLASSIFY(x);
-+	if (DUK_SIGNBIT((double) x)) {
-+		x = -x;
-+		neg = 1;
-+	} else {
-+		neg = 0;
-+	}
-+
-+	/* NaN sign bit is platform specific with unpacked, un-normalized NaNs */
-+	DUK_ASSERT(c == DUK_FP_NAN || DUK_SIGNBIT((double) x) == 0);
-+
-+	if (c == DUK_FP_NAN) {
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_NAN);
-+		return;
-+	} else if (c == DUK_FP_INFINITE) {
-+		if (neg) {
-+			/* -Infinity */
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_MINUS_INFINITY);
-+		} else {
-+			/* Infinity */
-+			duk_push_hstring_stridx(ctx, DUK_STRIDX_INFINITY);
-+		}
-+		return;
-+	} else if (c == DUK_FP_ZERO) {
-+		/* We can't shortcut zero here if it goes through special formatting
-+		 * (such as forced exponential notation).
-+		 */
-+		;
-+	}
-+
-+	/*
-+	 *  Handle integers in 32-bit range (that is, [-(2**32-1),2**32-1])
-+	 *  specially, as they're very likely for embedded programs.  This
-+	 *  is now done for all radix values.  We must be careful not to use
-+	 *  the fast path when special formatting (e.g. forced exponential)
-+	 *  is in force.
-+	 *
-+	 *  XXX: could save space by supporting radix 10 only and using
-+	 *  sprintf "%lu" for the fast path and for exponent formatting.
-+	 */
-+
-+	uval = (unsigned int) x;
-+	if (((double) uval) == x &&  /* integer number in range */
-+	    flags == 0) {            /* no special formatting */
-+		/* use bigint area as a temp */
-+		duk_uint8_t *buf = (duk_uint8_t *) (&nc_ctx->f);
-+		duk_uint8_t *p = buf;
-+
-+		DUK_ASSERT(DUK__NUMCONV_CTX_BIGINTS_SIZE >= 32 + 1);  /* max size: radix=2 + sign */
-+		if (neg && uval != 0) {
-+			/* no negative sign for zero */
-+			*p++ = (duk_uint8_t) '-';
-+		}
-+		p += duk__dragon4_format_uint32(p, uval, radix);
-+		duk_push_lstring(ctx, (const char *) buf, (duk_size_t) (p - buf));
-+		return;
-+	}
-+
-+	/*
-+	 *  Dragon4 setup.
-+	 *
-+	 *  Convert double from IEEE representation for conversion;
-+	 *  normal finite values have an implicit leading 1-bit.  The
-+	 *  slow path algorithm doesn't handle zero, so zero is special
-+	 *  cased here but still creates a valid nc_ctx, and goes
-+	 *  through normal formatting in case special formatting has
-+	 *  been requested (e.g. forced exponential format: 0 -> "0e+0").
-+	 */
-+
-+	/* Would be nice to bulk clear the allocation, but the context
-+	 * is 1-2 kilobytes and nothing should rely on it being zeroed.
-+	 */
-+#if 0
-+	DUK_MEMZERO((void *) nc_ctx, sizeof(*nc_ctx));  /* slow init, do only for slow path cases */
-+#endif
-+
-+	nc_ctx->is_s2n = 0;
-+	nc_ctx->b = 2;
-+	nc_ctx->B = radix;
-+	nc_ctx->abs_pos = 0;
-+	if (flags & DUK_N2S_FLAG_FIXED_FORMAT) {
-+		nc_ctx->is_fixed = 1;
-+		if (flags & DUK_N2S_FLAG_FRACTION_DIGITS) {
-+			/* absolute req_digits; e.g. digits = 1 -> last digit is 0,
-+			 * but add an extra digit for rounding.
-+			 */
-+			nc_ctx->abs_pos = 1;
-+			nc_ctx->req_digits = (-digits + 1) - 1;
-+		} else {
-+			nc_ctx->req_digits = digits + 1;
-+		}
-+	} else {
-+		nc_ctx->is_fixed = 0;
-+		nc_ctx->req_digits = 0;
-+	}
-+
-+	if (c == DUK_FP_ZERO) {
-+		/* Zero special case: fake requested number of zero digits; ensure
-+		 * no sign bit is printed.  Relative and absolute fixed format
-+		 * require separate handling.
-+		 */
-+		duk_small_int_t count;
-+		if (nc_ctx->is_fixed) {
-+			if (nc_ctx->abs_pos) {
-+				count = digits + 2;  /* lead zero + 'digits' fractions + 1 for rounding */
-+			} else {
-+				count = digits + 1;  /* + 1 for rounding */
-+			}
-+		} else {
-+			count = 1;
-+		}
-+		DUK_DDD(DUK_DDDPRINT("count=%ld", (long) count));
-+		DUK_ASSERT(count >= 1);
-+		DUK_MEMZERO((void *) nc_ctx->digits, count);
-+		nc_ctx->count = count;
-+		nc_ctx->k = 1;  /* 0.000... */
-+		neg = 0;
-+		goto zero_skip;
-+	}
-+
-+	duk__dragon4_double_to_ctx(nc_ctx, x);   /* -> sets 'f' and 'e' */
-+	DUK__BI_PRINT("f", &nc_ctx->f);
-+	DUK_DDD(DUK_DDDPRINT("e=%ld", (long) nc_ctx->e));
-+
-+	/*
-+	 *  Dragon4 slow path digit generation.
-+	 */
-+
-+	duk__dragon4_prepare(nc_ctx);  /* setup many variables in nc_ctx */
-+
-+	DUK_DDD(DUK_DDDPRINT("after prepare:"));
-+	DUK__BI_PRINT("r", &nc_ctx->r);
-+	DUK__BI_PRINT("s", &nc_ctx->s);
-+	DUK__BI_PRINT("mp", &nc_ctx->mp);
-+	DUK__BI_PRINT("mm", &nc_ctx->mm);
-+
-+	duk__dragon4_scale(nc_ctx);
-+
-+	DUK_DDD(DUK_DDDPRINT("after scale; k=%ld", (long) nc_ctx->k));
-+	DUK__BI_PRINT("r", &nc_ctx->r);
-+	DUK__BI_PRINT("s", &nc_ctx->s);
-+	DUK__BI_PRINT("mp", &nc_ctx->mp);
-+	DUK__BI_PRINT("mm", &nc_ctx->mm);
-+
-+	duk__dragon4_generate(nc_ctx);
-+
-+	/*
-+	 *  Convert and push final string.
-+	 */
-+
-+ zero_skip:
-+
-+	if (flags & DUK_N2S_FLAG_FIXED_FORMAT) {
-+		/* Perform fixed-format rounding. */
-+		duk_small_int_t roundpos;
-+		if (flags & DUK_N2S_FLAG_FRACTION_DIGITS) {
-+			/* 'roundpos' is relative to nc_ctx->k and increases to the right
-+			 * (opposite of how 'k' changes).
-+			 */
-+			roundpos = -digits;  /* absolute position for digit considered for rounding */
-+			roundpos = nc_ctx->k - roundpos;
-+		} else {
-+			roundpos = digits;
-+		}
-+		DUK_DDD(DUK_DDDPRINT("rounding: k=%ld, count=%ld, digits=%ld, roundpos=%ld",
-+		                     (long) nc_ctx->k, (long) nc_ctx->count, (long) digits, (long) roundpos));
-+		(void) duk__dragon4_fixed_format_round(nc_ctx, roundpos);
-+
-+		/* Note: 'count' is currently not adjusted by rounding (i.e. the
-+		 * digits are not "chopped off".  That shouldn't matter because
-+		 * the digit position (absolute or relative) is passed on to the
-+		 * convert-and-push function.
-+		 */
-+	}
-+
-+	duk__dragon4_convert_and_push(nc_ctx, ctx, radix, digits, flags, neg);
-+}
-+
-+/*
-+ *  Exposed string-to-number API
-+ *
-+ *  Input: [ string ]
-+ *  Output: [ number ]
-+ *
-+ *  If number parsing fails, a NaN is pushed as the result.  If number parsing
-+ *  fails due to an internal error, an InternalError is thrown.
-+ */
-+
-+DUK_INTERNAL void duk_numconv_parse(duk_context *ctx, duk_small_int_t radix, duk_small_uint_t flags) {
-+	duk_hthread *thr = (duk_hthread *) ctx;
-+	duk__numconv_stringify_ctx nc_ctx_alloc;  /* large context; around 2kB now */
-+	duk__numconv_stringify_ctx *nc_ctx = &nc_ctx_alloc;
-+	duk_double_t res;
-+	duk_hstring *h_str;
-+	duk_small_int_t expt;
-+	duk_small_int_t expt_neg;
-+	duk_small_int_t expt_adj;
-+	duk_small_int_t neg;
-+	duk_small_int_t dig;
-+	duk_small_int_t dig_whole;
-+	duk_small_int_t dig_lzero;
-+	duk_small_int_t dig_frac;
-+	duk_small_int_t dig_expt;
-+	duk_small_int_t dig_prec;
-+	const duk__exp_limits *explim;
-+	const duk_uint8_t *p;
-+	duk_small_int_t ch;
-+
-+	/* This seems to waste a lot of stack frame entries, but good compilers
-+	 * will compute these as needed below.  Some of these initial flags are
-+	 * also modified in the code below, so they can't all be removed.
-+	 */
-+	duk_small_int_t trim_white = (flags & DUK_S2N_FLAG_TRIM_WHITE);
-+	duk_small_int_t allow_expt = (flags & DUK_S2N_FLAG_ALLOW_EXP);
-+	duk_small_int_t allow_garbage = (flags & DUK_S2N_FLAG_ALLOW_GARBAGE);
-+	duk_small_int_t allow_plus = (flags & DUK_S2N_FLAG_ALLOW_PLUS);
-+	duk_small_int_t allow_minus = (flags & DUK_S2N_FLAG_ALLOW_MINUS);
-+	duk_small_int_t allow_infinity = (flags & DUK_S2N_FLAG_ALLOW_INF);
-+	duk_small_int_t allow_frac = (flags & DUK_S2N_FLAG_ALLOW_FRAC);
-+	duk_small_int_t allow_naked_frac = (flags & DUK_S2N_FLAG_ALLOW_NAKED_FRAC);
-+	duk_small_int_t allow_empty_frac = (flags & DUK_S2N_FLAG_ALLOW_EMPTY_FRAC);
-+	duk_small_int_t allow_empty = (flags & DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO);
-+	duk_small_int_t allow_leading_zero = (flags & DUK_S2N_FLAG_ALLOW_LEADING_ZERO);
-+	duk_small_int_t allow_auto_hex_int = (flags & DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT);
-+	duk_small_int_t allow_auto_oct_int = (flags & DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT);
-+
-+	DUK_DDD(DUK_DDDPRINT("parse number: %!T, radix=%ld, flags=0x%08lx",
-+	                     (duk_tval *) duk_get_tval(ctx, -1),
-+	                     (long) radix, (unsigned long) flags));
-+
-+	DUK_ASSERT(radix >= 2 && radix <= 36);
-+	DUK_ASSERT(radix - 2 < (duk_small_int_t) sizeof(duk__str2num_digits_for_radix));
-+
-+	/*
-+	 *  Preliminaries: trim, sign, Infinity check
-+	 *
-+	 *  We rely on the interned string having a NUL terminator, which will
-+	 *  cause a parse failure wherever it is encountered.  As a result, we
-+	 *  don't need separate pointer checks.
-+	 *
-+	 *  There is no special parsing for 'NaN' in the specification although
-+	 *  'Infinity' (with an optional sign) is allowed in some contexts.
-+	 *  Some contexts allow plus/minus sign, while others only allow the
-+	 *  minus sign (like JSON.parse()).
-+	 *
-+	 *  Automatic hex number detection (leading '0x' or '0X') and octal
-+	 *  number detection (leading '0' followed by at least one octal digit)
-+	 *  is done here too.
-+	 */
-+
-+	if (trim_white) {
-+		/* Leading / trailing whitespace is sometimes accepted and
-+		 * sometimes not.  After white space trimming, all valid input
-+		 * characters are pure ASCII.
-+		 */
-+		duk_trim(ctx, -1);
-+	}
-+	h_str = duk_require_hstring(ctx, -1);
-+	DUK_ASSERT(h_str != NULL);
-+	p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h_str);
-+
-+	neg = 0;
-+	ch = *p;
-+	if (ch == (duk_small_int_t) '+') {
-+		if (!allow_plus) {
-+			DUK_DDD(DUK_DDDPRINT("parse failed: leading plus sign not allowed"));
-+			goto parse_fail;
-+		}
-+		p++;
-+	} else if (ch == (duk_small_int_t) '-') {
-+		if (!allow_minus) {
-+			DUK_DDD(DUK_DDDPRINT("parse failed: leading minus sign not allowed"));
-+			goto parse_fail;
-+		}
-+		p++;
-+		neg = 1;
-+	}
-+
-+	ch = *p;
-+	if (allow_infinity && ch == (duk_small_int_t) 'I') {
-+		/* Don't check for Infinity unless the context allows it.
-+		 * 'Infinity' is a valid integer literal in e.g. base-36:
-+		 *
-+		 *   parseInt('Infinity', 36)
-+		 *   1461559270678
-+		 */
-+
-+		const duk_uint8_t *q;
-+
-+		/* borrow literal Infinity from builtin string */
-+		q = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(DUK_HTHREAD_STRING_INFINITY(thr));
-+		if (DUK_STRNCMP((const char *) p, (const char *) q, 8) == 0) {
-+			if (!allow_garbage && (p[8] != (duk_uint8_t) 0)) {
-+				DUK_DDD(DUK_DDDPRINT("parse failed: trailing garbage after matching 'Infinity' not allowed"));
-+				goto parse_fail;
-+			} else {
-+				res = DUK_DOUBLE_INFINITY;
-+				goto negcheck_and_ret;
-+			}
-+		}
-+	}
-+	if (ch == (duk_small_int_t) '0') {
-+		duk_small_int_t detect_radix = 0;
-+		ch = p[1];
-+		if (allow_auto_hex_int && (ch == (duk_small_int_t) 'x' || ch == (duk_small_int_t) 'X')) {
-+			DUK_DDD(DUK_DDDPRINT("detected 0x/0X hex prefix, changing radix and preventing fractions and exponent"));
-+			detect_radix = 16;
-+			allow_empty = 0;  /* interpret e.g. '0x' and '0xg' as a NaN (= parse error) */
-+			p += 2;
-+		} else if (allow_auto_oct_int && (ch >= (duk_small_int_t) '0' && ch <= (duk_small_int_t) '9')) {
-+			DUK_DDD(DUK_DDDPRINT("detected 0n oct prefix, changing radix and preventing fractions and exponent"));
-+			detect_radix = 8;
-+			allow_empty = 1;  /* interpret e.g. '09' as '0', not NaN */
-+			p += 1;
-+		}
-+		if (detect_radix > 0) {
-+			radix = detect_radix;
-+			allow_expt = 0;
-+			allow_frac = 0;
-+			allow_naked_frac = 0;
-+			allow_empty_frac = 0;
-+			allow_leading_zero = 1;  /* allow e.g. '0x0009' and '00077' */
-+		}
-+	}
-+
-+	/*
-+	 *  Scan number and setup for Dragon4.
-+	 *
-+	 *  The fast path case is detected during setup: an integer which
-+	 *  can be converted without rounding, no net exponent.  The fast
-+	 *  path could be implemented as a separate scan, but may not really
-+	 *  be worth it: the multiplications for building 'f' are not
-+	 *  expensive when 'f' is small.
-+	 *
-+	 *  The significand ('f') must contain enough bits of (apparent)
-+	 *  accuracy, so that Dragon4 will generate enough binary output digits.
-+	 *  For decimal numbers, this means generating a 20-digit significand,
-+	 *  which should yield enough practical accuracy to parse IEEE doubles.
-+	 *  In fact, the Ecmascript specification explicitly allows an
-+	 *  implementation to treat digits beyond 20 as zeroes (and even
-+	 *  to round the 20th digit upwards).  For non-decimal numbers, the
-+	 *  appropriate number of digits has been precomputed for comparable
-+	 *  accuracy.
-+	 *
-+	 *  Digit counts:
-+	 *
-+	 *    [ dig_lzero ]
-+	 *      |
-+	 *     .+-..---[ dig_prec ]----.
-+	 *     |  ||                   |
-+	 *     0000123.456789012345678901234567890e+123456
-+	 *     |     | |                         |  |    |
-+	 *     `--+--' `------[ dig_frac ]-------'  `-+--'
-+	 *        |                                   |
-+	 *    [ dig_whole ]                       [ dig_expt ]
-+	 *
-+	 *    dig_frac and dig_expt are -1 if not present
-+	 *    dig_lzero is only computed for whole number part
-+	 *
-+	 *  Parsing state
-+	 *
-+	 *     Parsing whole part      dig_frac < 0 AND dig_expt < 0
-+	 *     Parsing fraction part   dig_frac >= 0 AND dig_expt < 0
-+	 *     Parsing exponent part   dig_expt >= 0   (dig_frac may be < 0 or >= 0)
-+	 *
-+	 *  Note: in case we hit an implementation limit (like exponent range),
-+	 *  we should throw an error, NOT return NaN or Infinity.  Even with
-+	 *  very large exponent (or significand) values the final result may be
-+	 *  finite, so NaN/Infinity would be incorrect.
-+	 */
-+
-+	duk__bi_set_small(&nc_ctx->f, 0);
-+	dig_prec = 0;
-+	dig_lzero = 0;
-+	dig_whole = 0;
-+	dig_frac = -1;
-+	dig_expt = -1;
-+	expt = 0;
-+	expt_adj = 0;  /* essentially tracks digit position of lowest 'f' digit */
-+	expt_neg = 0;
-+	for (;;) {
-+		ch = *p++;
-+
-+		DUK_DDD(DUK_DDDPRINT("parse digits: p=%p, ch='%c' (%ld), expt=%ld, expt_adj=%ld, "
-+		                     "dig_whole=%ld, dig_frac=%ld, dig_expt=%ld, dig_lzero=%ld, dig_prec=%ld",
-+		                     (void *) p, (int) ((ch >= 0x20 && ch <= 0x7e) ? ch : '?'), (long) ch,
-+		                     (long) expt, (long) expt_adj, (long) dig_whole, (long) dig_frac,
-+		                     (long) dig_expt, (long) dig_lzero, (long) dig_prec));
-+		DUK__BI_PRINT("f", &nc_ctx->f);
-+
-+		/* Most common cases first. */
-+		if (ch >= (duk_small_int_t) '0' && ch <= (duk_small_int_t) '9') {
-+			dig = (int) ch - '0' + 0;
-+		} else if (ch == (duk_small_int_t) '.') {
-+			/* A leading digit is not required in some cases, e.g. accept ".123".
-+			 * In other cases (JSON.parse()) a leading digit is required.  This
-+			 * is checked for after the loop.
-+			 */
-+			if (dig_frac >= 0 || dig_expt >= 0) {
-+				if (allow_garbage) {
-+					DUK_DDD(DUK_DDDPRINT("garbage termination (invalid period)"));
-+					break;
-+				} else {
-+					DUK_DDD(DUK_DDDPRINT("parse failed: period not allowed"));
-+					goto parse_fail;
-+				}
-+			}
-+
-+			if (!allow_frac) {
-+				/* Some contexts don't allow fractions at all; this can't be a
-+				 * post-check because the state ('f' and expt) would be incorrect.
-+				 */
-+				if (allow_garbage) {
-+					DUK_DDD(DUK_DDDPRINT("garbage termination (invalid first period)"));
-+					break;
-+				} else {
-+					DUK_DDD(DUK_DDDPRINT("parse failed: fraction part not allowed"));
-+				}
-+			}
-+
-+			DUK_DDD(DUK_DDDPRINT("start fraction part"));
-+			dig_frac = 0;
-+			continue;
-+		} else if (ch == (duk_small_int_t) 0) {
-+			DUK_DDD(DUK_DDDPRINT("NUL termination"));
-+			break;
-+		} else if (allow_expt && dig_expt < 0 && (ch == (duk_small_int_t) 'e' || ch == (duk_small_int_t) 'E')) {
-+			/* Note: we don't parse back exponent notation for anything else
-+			 * than radix 10, so this is not an ambiguous check (e.g. hex
-+			 * exponent values may have 'e' either as a significand digit
-+			 * or as an exponent separator).
-+			 *
-+			 * If the exponent separator occurs twice, 'e' will be interpreted
-+			 * as a digit (= 14) and will be rejected as an invalid decimal
-+			 * digit.
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("start exponent part"));
-+
-+			/* Exponent without a sign or with a +/- sign is accepted
-+			 * by all call sites (even JSON.parse()).
-+			 */
-+			ch = *p;
-+			if (ch == (duk_small_int_t) '-') {
-+				expt_neg = 1;
-+				p++;
-+			} else if (ch == (duk_small_int_t) '+') {
-+				p++;
-+			}
-+			dig_expt = 0;
-+			continue;
-+		} else if (ch >= (duk_small_int_t) 'a' && ch <= (duk_small_int_t) 'z') {
-+			dig = (duk_small_int_t) (ch - (duk_small_int_t) 'a' + 0x0a);
-+		} else if (ch >= (duk_small_int_t) 'A' && ch <= (duk_small_int_t) 'Z') {
-+			dig = (duk_small_int_t) (ch - (duk_small_int_t) 'A' + 0x0a);
-+		} else {
-+			dig = 255;  /* triggers garbage digit check below */
-+		}
-+		DUK_ASSERT((dig >= 0 && dig <= 35) || dig == 255);
-+
-+		if (dig >= radix) {
-+			if (allow_garbage) {
-+				DUK_DDD(DUK_DDDPRINT("garbage termination"));
-+				break;
-+			} else {
-+				DUK_DDD(DUK_DDDPRINT("parse failed: trailing garbage or invalid digit"));
-+				goto parse_fail;
-+			}
-+		}
-+
-+		if (dig_expt < 0) {
-+			/* whole or fraction digit */
-+
-+			if (dig_prec < duk__str2num_digits_for_radix[radix - 2]) {
-+				/* significant from precision perspective */
-+
-+				duk_small_int_t f_zero = duk__bi_is_zero(&nc_ctx->f);
-+				if (f_zero && dig == 0) {
-+					/* Leading zero is not counted towards precision digits; not
-+					 * in the integer part, nor in the fraction part.
-+					 */
-+					if (dig_frac < 0) {
-+						dig_lzero++;
-+					}
-+				} else {
-+					/* XXX: join these ops (multiply-accumulate), but only if
-+					 * code footprint decreases.
-+					 */
-+					duk__bi_mul_small(&nc_ctx->t1, &nc_ctx->f, radix);
-+					duk__bi_add_small(&nc_ctx->f, &nc_ctx->t1, dig);
-+					dig_prec++;
-+				}
-+			} else {
-+				/* Ignore digits beyond a radix-specific limit, but note them
-+				 * in expt_adj.
-+				 */
-+				expt_adj++;
-+			}
-+
-+			if (dig_frac >= 0) {
-+				dig_frac++;
-+				expt_adj--;
-+			} else {
-+				dig_whole++;
-+			}
-+		} else {
-+			/* exponent digit */
-+
-+			expt = expt * radix + dig;
-+			if (expt > DUK_S2N_MAX_EXPONENT) {
-+				/* impose a reasonable exponent limit, so that exp
-+				 * doesn't need to get tracked using a bigint.
-+				 */
-+				DUK_DDD(DUK_DDDPRINT("parse failed: exponent too large"));
-+				goto parse_int_error;
-+			}
-+			dig_expt++;
-+		}
-+	}
-+
-+	/* Leading zero. */
-+
-+	if (dig_lzero > 0 && dig_whole > 1) {
-+		if (!allow_leading_zero) {
-+			DUK_DDD(DUK_DDDPRINT("parse failed: leading zeroes not allowed in integer part"));
-+			goto parse_fail;
-+		}
-+	}
-+
-+	/* Validity checks for various fraction formats ("0.1", ".1", "1.", "."). */
-+
-+	if (dig_whole == 0) {
-+		if (dig_frac == 0) {
-+			/* "." is not accepted in any format */
-+			DUK_DDD(DUK_DDDPRINT("parse failed: plain period without leading or trailing digits"));
-+			goto parse_fail;
-+		} else if (dig_frac > 0) {
-+			/* ".123" */
-+			if (!allow_naked_frac) {
-+				DUK_DDD(DUK_DDDPRINT("parse failed: fraction part not allowed without "
-+				                     "leading integer digit(s)"));
-+				goto parse_fail;
-+			}
-+		} else {
-+			/* empty ("") is allowed in some formats (e.g. Number(''), as zero */
-+			if (!allow_empty) {
-+				DUK_DDD(DUK_DDDPRINT("parse failed: empty string not allowed (as zero)"));
-+				goto parse_fail;
-+			}
-+		}
-+	} else {
-+		if (dig_frac == 0) {
-+			/* "123." is allowed in some formats */
-+			if (!allow_empty_frac) {
-+				DUK_DDD(DUK_DDDPRINT("parse failed: empty fractions"));
-+				goto parse_fail;
-+			}
-+		} else if (dig_frac > 0) {
-+			/* "123.456" */
-+			;
-+		} else {
-+			/* "123" */
-+			;
-+		}
-+	}
-+
-+	/* Exponent without digits (e.g. "1e" or "1e+").  If trailing garbage is
-+	 * allowed, ignore exponent part as garbage (= parse as "1", i.e. exp 0).
-+	 */
-+
-+	if (dig_expt == 0) {
-+		if (!allow_garbage) {
-+			DUK_DDD(DUK_DDDPRINT("parse failed: empty exponent"));
-+			goto parse_fail;
-+		}
-+		DUK_ASSERT(expt == 0);
-+	}
-+
-+	if (expt_neg) {
-+		expt = -expt;
-+	}
-+	DUK_DDD(DUK_DDDPRINT("expt=%ld, expt_adj=%ld, net exponent -> %ld",
-+	                     (long) expt, (long) expt_adj, (long) (expt + expt_adj)));
-+	expt += expt_adj;
-+
-+	/* Fast path check. */
-+
-+	if (nc_ctx->f.n <= 1 &&   /* 32-bit value */
-+	    expt == 0    /* no net exponent */) {
-+		/* Fast path is triggered for no exponent and also for balanced exponent
-+		 * and fraction parts, e.g. for "1.23e2" == "123".  Remember to respect
-+		 * zero sign.
-+		 */
-+
-+		/* XXX: could accept numbers larger than 32 bits, e.g. up to 53 bits? */
-+		DUK_DDD(DUK_DDDPRINT("fast path number parse"));
-+		if (nc_ctx->f.n == 1) {
-+			res = (double) nc_ctx->f.v[0];
-+		} else {
-+			res = 0.0;
-+		}
-+		goto negcheck_and_ret;
-+	}
-+
-+	/* Significand ('f') padding. */
-+
-+	while (dig_prec < duk__str2num_digits_for_radix[radix - 2]) {
-+		/* Pad significand with "virtual" zero digits so that Dragon4 will
-+		 * have enough (apparent) precision to work with.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("dig_prec=%ld, pad significand with zero", (long) dig_prec));
-+		duk__bi_mul_small_copy(&nc_ctx->f, radix, &nc_ctx->t1);
-+		DUK__BI_PRINT("f", &nc_ctx->f);
-+		expt--;
-+		dig_prec++;
-+	}
-+
-+	DUK_DDD(DUK_DDDPRINT("final exponent: %ld", (long) expt));
-+
-+	/* Detect zero special case. */
-+
-+	if (nc_ctx->f.n == 0) {
-+		/* This may happen even after the fast path check, if exponent is
-+		 * not balanced (e.g. "0e1").  Remember to respect zero sign.
-+		 */
-+		DUK_DDD(DUK_DDDPRINT("significand is zero"));
-+		res = 0.0;
-+		goto negcheck_and_ret;
-+	}
-+
-+
-+	/* Quick reject of too large or too small exponents.  This check
-+	 * would be incorrect for zero (e.g. "0e1000" is zero, not Infinity)
-+	 * so zero check must be above.
-+	 */
-+
-+	explim = &duk__str2num_exp_limits[radix - 2];
-+	if (expt > explim->upper) {
-+		DUK_DDD(DUK_DDDPRINT("exponent too large -> infinite"));
-+		res = (duk_double_t) DUK_DOUBLE_INFINITY;
-+		goto negcheck_and_ret;
-+	} else if (expt < explim->lower) {
-+		DUK_DDD(DUK_DDDPRINT("exponent too small -> zero"));
-+		res = (duk_double_t) 0.0;
-+		goto negcheck_and_ret;
-+	}
-+
-+	nc_ctx->is_s2n = 1;
-+	nc_ctx->e = expt;
-+	nc_ctx->b = radix;
-+	nc_ctx->B = 2;
-+	nc_ctx->is_fixed = 1;
-+	nc_ctx->abs_pos = 0;
-+	nc_ctx->req_digits = 53 + 1;
-+
-+	DUK__BI_PRINT("f", &nc_ctx->f);
-+	DUK_DDD(DUK_DDDPRINT("e=%ld", (long) nc_ctx->e));
-+
-+	/*
-+	 *  Dragon4 slow path (binary) digit generation.
-+	 *  An extra digit is generated for rounding.
-+	 */
-+
-+	duk__dragon4_prepare(nc_ctx);  /* setup many variables in nc_ctx */
-+
-+	DUK_DDD(DUK_DDDPRINT("after prepare:"));
-+	DUK__BI_PRINT("r", &nc_ctx->r);
-+	DUK__BI_PRINT("s", &nc_ctx->s);
-+	DUK__BI_PRINT("mp", &nc_ctx->mp);
-+	DUK__BI_PRINT("mm", &nc_ctx->mm);
-+
-+	duk__dragon4_scale(nc_ctx);
-+
-+	DUK_DDD(DUK_DDDPRINT("after scale; k=%ld", (long) nc_ctx->k));
-+	DUK__BI_PRINT("r", &nc_ctx->r);
-+	DUK__BI_PRINT("s", &nc_ctx->s);
-+	DUK__BI_PRINT("mp", &nc_ctx->mp);
-+	DUK__BI_PRINT("mm", &nc_ctx->mm);
-+
-+	duk__dragon4_generate(nc_ctx);
-+
-+	DUK_ASSERT(nc_ctx->count == 53 + 1);
-+
-+	/*
-+	 *  Convert binary digits into an IEEE double.  Need to handle
-+	 *  denormals and rounding correctly.
-+	 */
-+
-+	duk__dragon4_ctx_to_double(nc_ctx, &res);
-+	goto negcheck_and_ret;
-+
-+ negcheck_and_ret:
-+	if (neg) {
-+		res = -res;
-+	}
-+	duk_pop(ctx);
-+	duk_push_number(ctx, (double) res);
-+	DUK_DDD(DUK_DDDPRINT("result: %!T", (duk_tval *) duk_get_tval(ctx, -1)));
-+	return;
-+
-+ parse_fail:
-+	DUK_DDD(DUK_DDDPRINT("parse failed"));
-+	duk_pop(ctx);
-+	duk_push_nan(ctx);
-+	return;
-+
-+ parse_int_error:
-+	DUK_DDD(DUK_DDDPRINT("parse failed, internal error, can't return a value"));
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, "number parse error");
-+	return;
-+}
-+#line 1 "duk_regexp_compiler.c"
-+/*
-+ *  Regexp compilation.
-+ *
-+ *  See doc/regexp.txt for a discussion of the compilation approach and
-+ *  current limitations.
-+ *
-+ *  Regexp bytecode assumes jumps can be expressed with signed 32-bit
-+ *  integers.  Consequently the bytecode size must not exceed 0x7fffffffL.
-+ *  The implementation casts duk_size_t (buffer size) to duk_(u)int32_t
-+ *  in many places.  Although this could be changed, the bytecode format
-+ *  limit would still prevent regexps exceeding the signed 32-bit limit
-+ *  from working.
-+ *
-+ *  XXX: The implementation does not prevent bytecode from exceeding the
-+ *  maximum supported size.  This could be done by limiting the maximum
-+ *  input string size (assuming an upper bound can be computed for number
-+ *  of bytecode bytes emitted per input byte) or checking buffer maximum
-+ *  size when emitting bytecode (slower).
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+
-+/*
-+ *  Helper macros
-+ */
-+
-+#ifdef DUK__BUFLEN
-+#undef DUK__BUFLEN
-+#endif
-+
-+#define DUK__BUFLEN(re_ctx)   DUK_HBUFFER_GET_SIZE((duk_hbuffer *) re_ctx->buf)
-+
-+/*
-+ *  Disjunction struct: result of parsing a disjunction
-+ */
-+
-+typedef struct {
-+	/* Number of characters that the atom matches (e.g. 3 for 'abc'),
-+	 * -1 if atom is complex and number of matched characters either
-+	 * varies or is not known.
-+	 */
-+	duk_int32_t charlen;
-+
-+#if 0
-+	/* These are not needed to implement quantifier capture handling,
-+	 * but might be needed at some point.
-+	 */
-+
-+	/* re_ctx->captures at start and end of atom parsing.
-+	 * Since 'captures' indicates highest capture number emitted
-+	 * so far in a DUK_REOP_SAVE, the captures numbers saved by
-+	 * the atom are: ]start_captures,end_captures].
-+	 */
-+	duk_uint32_t start_captures;
-+	duk_uint32_t end_captures;
-+#endif
-+} duk__re_disjunction_info;
-+
-+/*
-+ *  Encoding helpers
-+ *
-+ *  Some of the typing is bytecode based, e.g. slice sizes are unsigned 32-bit
-+ *  even though the buffer operations will use duk_size_t.
-+ */
-+
-+/* XXX: the insert helpers should ensure that the bytecode result is not
-+ * larger than expected (or at least assert for it).  Many things in the
-+ * bytecode, like skip offsets, won't work correctly if the bytecode is
-+ * larger than say 2G.
-+ */
-+
-+DUK_LOCAL duk_uint32_t duk__encode_i32(duk_int32_t x) {
-+	if (x < 0) {
-+		return ((duk_uint32_t) (-x)) * 2 + 1;
-+	} else {
-+		return ((duk_uint32_t) x) * 2;
-+	}
-+}
-+
-+/* XXX: return type should probably be duk_size_t, or explicit checks are needed for
-+ * maximum size.
-+ */
-+DUK_LOCAL duk_uint32_t duk__insert_u32(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t x) {
-+	return (duk_uint32_t) duk_hbuffer_insert_xutf8(re_ctx->thr, re_ctx->buf, offset, x);
-+}
-+
-+DUK_LOCAL duk_uint32_t duk__append_u32(duk_re_compiler_ctx *re_ctx, duk_uint32_t x) {
-+	return (duk_uint32_t) duk_hbuffer_append_xutf8(re_ctx->thr, re_ctx->buf, x);
-+}
-+
-+DUK_LOCAL duk_uint32_t duk__insert_i32(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t x) {
-+	return (duk_uint32_t) duk_hbuffer_insert_xutf8(re_ctx->thr, re_ctx->buf, offset, duk__encode_i32(x));
-+}
-+
-+#if 0  /* unused */
-+DUK_LOCAL duk_uint32_t duk__append_i32(duk_re_compiler_ctx *re_ctx, duk_int32_t x) {
-+	return duk_hbuffer_append_xutf8(re_ctx->thr, re_ctx->buf, duk__encode_i32(x));
-+}
-+#endif
-+
-+/* special helper for emitting u16 lists (used for character ranges for built-in char classes) */
-+DUK_LOCAL void duk__append_u16_list(duk_re_compiler_ctx *re_ctx, duk_uint16_t *values, duk_uint32_t count) {
-+	/* Call sites don't need the result length so it's not accumulated. */
-+	while (count > 0) {
-+		(void) duk__append_u32(re_ctx, (duk_uint32_t) (*values++));
-+		count--;
-+	}
-+}
-+
-+DUK_LOCAL void duk__insert_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t data_offset, duk_uint32_t data_length) {
-+	duk_hbuffer_insert_slice(re_ctx->thr, re_ctx->buf, offset, data_offset, (duk_size_t) data_length);
-+}
-+
-+DUK_LOCAL void duk__append_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t data_offset, duk_uint32_t data_length) {
-+	duk_hbuffer_append_slice(re_ctx->thr, re_ctx->buf, data_offset, (duk_size_t) data_length);
-+}
-+
-+DUK_LOCAL void duk__remove_slice(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_uint32_t length) {
-+	duk_hbuffer_remove_slice(re_ctx->thr, re_ctx->buf, offset, (duk_size_t) length);
-+}
-+
-+/*
-+ *  Insert a jump offset at 'offset' to complete an instruction
-+ *  (the jump offset is always the last component of an instruction).
-+ *  The 'skip' argument must be computed relative to 'offset',
-+ *  -without- taking into account the skip field being inserted.
-+ *
-+ *       ... A B C ins X Y Z ...   (ins may be a JUMP, SPLIT1/SPLIT2, etc)
-+ *   =>  ... A B C ins SKIP X Y Z
-+ *
-+ *  Computing the final (adjusted) skip value, which is relative to the
-+ *  first byte of the next instruction, is a bit tricky because of the
-+ *  variable length UTF-8 encoding.  See doc/regexp.txt for discussion.
-+ */
-+DUK_LOCAL duk_uint32_t duk__insert_jump_offset(duk_re_compiler_ctx *re_ctx, duk_uint32_t offset, duk_int32_t skip) {
-+	duk_small_int_t len;
-+
-+	/* XXX: solve into closed form (smaller code) */
-+
-+	if (skip < 0) {
-+		/* two encoding attempts suffices */
-+		len = duk_unicode_get_xutf8_length((duk_codepoint_t) duk__encode_i32(skip));
-+		len = duk_unicode_get_xutf8_length((duk_codepoint_t) duk__encode_i32(skip - (duk_int32_t) len));
-+		DUK_ASSERT(duk_unicode_get_xutf8_length(duk__encode_i32(skip - (duk_int32_t) len)) == len);  /* no change */
-+		skip -= (duk_int32_t) len;
-+	}
-+	return duk__insert_i32(re_ctx, offset, skip);
-+}
-+
-+DUK_LOCAL duk_uint32_t duk__append_jump_offset(duk_re_compiler_ctx *re_ctx, duk_int32_t skip) {
-+	return (duk_uint32_t) duk__insert_jump_offset(re_ctx, (duk_uint32_t) DUK__BUFLEN(re_ctx), skip);
-+}
-+
-+/*
-+ *  duk_re_range_callback for generating character class ranges.
-+ *
-+ *  When ignoreCase is false, the range is simply emitted as is.
-+ *  We don't, for instance, eliminate duplicates or overlapping
-+ *  ranges in a character class.
-+ *
-+ *  When ignoreCase is true, the range needs to be normalized through
-+ *  canonicalization.  Unfortunately a canonicalized version of a
-+ *  continuous range is not necessarily continuous (e.g. [x-{] is
-+ *  continuous but [X-{] is not).  The current algorithm creates the
-+ *  canonicalized range(s) space efficiently at the cost of compile
-+ *  time execution time (see doc/regexp.txt for discussion).
-+ *
-+ *  Note that the ctx->nranges is a context-wide temporary value
-+ *  (this is OK because there cannot be multiple character classes
-+ *  being parsed simultaneously).
-+ */
-+
-+DUK_LOCAL void duk__generate_ranges(void *userdata, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct) {
-+	duk_re_compiler_ctx *re_ctx = (duk_re_compiler_ctx *) userdata;
-+
-+	DUK_DD(DUK_DDPRINT("duk__generate_ranges(): re_ctx=%p, range=[%ld,%ld] direct=%ld",
-+	                   (void *) re_ctx, (long) r1, (long) r2, (long) direct));
-+
-+	if (!direct && (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE)) {
-+		/*
-+		 *  Canonicalize a range, generating result ranges as necessary.
-+		 *  Needs to exhaustively scan the entire range (at most 65536
-+		 *  code points).  If 'direct' is set, caller (lexer) has ensured
-+		 *  that the range is already canonicalization compatible (this
-+		 *  is used to avoid unnecessary canonicalization of built-in
-+		 *  ranges like \W, which are not affected by canonicalization).
-+		 *
-+		 *  NOTE: here is one place where we don't want to support chars
-+		 *  outside the BMP, because the exhaustive search would be
-+		 *  massively larger.
-+		 */
-+
-+		duk_codepoint_t i;
-+		duk_codepoint_t t;
-+		duk_codepoint_t r_start, r_end;
-+
-+		r_start = duk_unicode_re_canonicalize_char(re_ctx->thr, r1);
-+		r_end = r_start;
-+		for (i = r1 + 1; i <= r2; i++) {
-+			t = duk_unicode_re_canonicalize_char(re_ctx->thr, i);
-+			if (t == r_end + 1) {
-+				r_end = t;
-+			} else {
-+				DUK_DD(DUK_DDPRINT("canonicalized, emit range: [%ld,%ld]", (long) r_start, (long) r_end));
-+				duk__append_u32(re_ctx, (duk_uint32_t) r_start);
-+				duk__append_u32(re_ctx, (duk_uint32_t) r_end);
-+				re_ctx->nranges++;
-+				r_start = t;
-+				r_end = t;
-+			}
-+		}
-+		DUK_DD(DUK_DDPRINT("canonicalized, emit range: [%ld,%ld]", (long) r_start, (long) r_end));
-+		duk__append_u32(re_ctx, (duk_uint32_t) r_start);
-+		duk__append_u32(re_ctx, (duk_uint32_t) r_end);
-+		re_ctx->nranges++;
-+	} else {
-+		DUK_DD(DUK_DDPRINT("direct, emit range: [%ld,%ld]", (long) r1, (long) r2));
-+		duk__append_u32(re_ctx, (duk_uint32_t) r1);
-+		duk__append_u32(re_ctx, (duk_uint32_t) r2);
-+		re_ctx->nranges++;
-+	}
-+}
-+
-+/*
-+ *  Parse regexp Disjunction.  Most of regexp compilation happens here.
-+ *
-+ *  Handles Disjunction, Alternative, and Term productions directly without
-+ *  recursion.  The only constructs requiring recursion are positive/negative
-+ *  lookaheads, capturing parentheses, and non-capturing parentheses.
-+ *
-+ *  The function determines whether the entire disjunction is a 'simple atom'
-+ *  (see doc/regexp.txt discussion on 'simple quantifiers') and if so,
-+ *  returns the atom character length which is needed by the caller to keep
-+ *  track of its own atom character length.  A disjunction with more than one
-+ *  alternative is never considered a simple atom (although in some cases
-+ *  that might be the case).
-+ *
-+ *  Return value: simple atom character length or < 0 if not a simple atom.
-+ *  Appends the bytecode for the disjunction matcher to the end of the temp
-+ *  buffer.
-+ *
-+ *  Regexp top level structure is:
-+ *
-+ *    Disjunction = Term*
-+ *                | Term* | Disjunction
-+ *
-+ *    Term = Assertion
-+ *         | Atom
-+ *         | Atom Quantifier
-+ *
-+ *  An empty Term sequence is a valid disjunction alternative (e.g. /|||c||/).
-+ *
-+ *  Notes:
-+ *
-+ *    * Tracking of the 'simple-ness' of the current atom vs. the entire
-+ *      disjunction are separate matters.  For instance, the disjunction
-+ *      may be complex, but individual atoms may be simple.  Furthermore,
-+ *      simple quantifiers are used whenever possible, even if the
-+ *      disjunction as a whole is complex.
-+ *
-+ *    * The estimate of whether an atom is simple is conservative now,
-+ *      and it would be possible to expand it.  For instance, captures
-+ *      cause the disjunction to be marked complex, even though captures
-+ *      -can- be handled by simple quantifiers with some minor modifications.
-+ *
-+ *    * Disjunction 'tainting' as 'complex' is handled at the end of the
-+ *      main for loop collectively for atoms.  Assertions, quantifiers,
-+ *      and '|' tokens need to taint the result manually if necessary.
-+ *      Assertions cannot add to result char length, only atoms (and
-+ *      quantifiers) can; currently quantifiers will taint the result
-+ *      as complex though.
-+ */
-+
-+DUK_LOCAL void duk__parse_disjunction(duk_re_compiler_ctx *re_ctx, duk_bool_t expect_eof, duk__re_disjunction_info *out_atom_info) {
-+	duk_int32_t atom_start_offset = -1;                   /* negative -> no atom matched on previous round */
-+	duk_int32_t atom_char_length = 0;                     /* negative -> complex atom */
-+	duk_uint32_t atom_start_captures = re_ctx->captures;  /* value of re_ctx->captures at start of atom */
-+	duk_int32_t unpatched_disjunction_split = -1;
-+	duk_int32_t unpatched_disjunction_jump = -1;
-+	duk_uint32_t entry_offset = (duk_uint32_t) DUK__BUFLEN(re_ctx);
-+	duk_int32_t res_charlen = 0;  /* -1 if disjunction is complex, char length if simple */
-+	duk__re_disjunction_info tmp_disj;
-+
-+	DUK_ASSERT(out_atom_info != NULL);
-+
-+	if (re_ctx->recursion_depth >= re_ctx->recursion_limit) {
-+		DUK_ERROR(re_ctx->thr, DUK_ERR_RANGE_ERROR,
-+		          DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT);
-+	}
-+	re_ctx->recursion_depth++;
-+
-+#if 0
-+	out_atom_info->start_captures = re_ctx->captures;
-+#endif
-+
-+	for (;;) {
-+		/* atom_char_length, atom_start_offset, atom_start_offset reflect the
-+		 * atom matched on the previous loop.  If a quantifier is encountered
-+		 * on this loop, these are needed to handle the quantifier correctly.
-+		 * new_atom_char_length etc are for the atom parsed on this round;
-+		 * they're written to atom_char_length etc at the end of the round.
-+		 */
-+		duk_int32_t new_atom_char_length;   /* char length of the atom parsed in this loop */
-+		duk_int32_t new_atom_start_offset;  /* bytecode start offset of the atom parsed in this loop
-+		                                     * (allows quantifiers to copy the atom bytecode)
-+		                                     */
-+		duk_uint32_t new_atom_start_captures;  /* re_ctx->captures at the start of the atom parsed in this loop */
-+
-+		duk_lexer_parse_re_token(&re_ctx->lex, &re_ctx->curr_token);
-+
-+		DUK_DD(DUK_DDPRINT("re token: %ld (num=%ld, char=%c)",
-+		                   (long) re_ctx->curr_token.t,
-+		                   (long) re_ctx->curr_token.num,
-+		                   (re_ctx->curr_token.num >= 0x20 && re_ctx->curr_token.num <= 0x7e) ?
-+		                   (int) re_ctx->curr_token.num : (int) '?'));
-+
-+		/* set by atom case clauses */
-+		new_atom_start_offset = -1;
-+		new_atom_char_length = -1;
-+		new_atom_start_captures = re_ctx->captures;
-+
-+		switch (re_ctx->curr_token.t) {
-+		case DUK_RETOK_DISJUNCTION: {
-+			/*
-+			 *  The handling here is a bit tricky.  If a previous '|' has been processed,
-+			 *  we have a pending split1 and a pending jump (for a previous match).  These
-+			 *  need to be back-patched carefully.  See docs for a detailed example.
-+			 */
-+
-+			/* patch pending jump and split */
-+			if (unpatched_disjunction_jump >= 0) {
-+				duk_uint32_t offset;
-+
-+				DUK_ASSERT(unpatched_disjunction_split >= 0);
-+				offset = unpatched_disjunction_jump;
-+				offset += duk__insert_jump_offset(re_ctx,
-+				                                  offset,
-+				                                  (duk_int32_t) (DUK__BUFLEN(re_ctx) - offset));
-+				/* offset is now target of the pending split (right after jump) */
-+				duk__insert_jump_offset(re_ctx,
-+				                        unpatched_disjunction_split,
-+				                        offset - unpatched_disjunction_split);
-+			}
-+
-+			/* add a new pending split to the beginning of the entire disjunction */
-+			(void) duk__insert_u32(re_ctx,
-+			                       entry_offset,
-+			                       DUK_REOP_SPLIT1);   /* prefer direct execution */
-+			unpatched_disjunction_split = entry_offset + 1;   /* +1 for opcode */
-+
-+			/* add a new pending match jump for latest finished alternative */
-+			duk__append_u32(re_ctx, DUK_REOP_JUMP);
-+			unpatched_disjunction_jump = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+
-+			/* 'taint' result as complex */
-+			res_charlen = -1;
-+			break;
-+		}
-+		case DUK_RETOK_QUANTIFIER: {
-+			if (atom_start_offset < 0) {
-+				DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+				          DUK_STR_INVALID_QUANTIFIER_NO_ATOM);
-+			}
-+			if (re_ctx->curr_token.qmin > re_ctx->curr_token.qmax) {
-+				DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+				          DUK_STR_INVALID_QUANTIFIER_VALUES);
-+			}
-+			if (atom_char_length >= 0) {
-+				/*
-+				 *  Simple atom
-+				 *
-+				 *  If atom_char_length is zero, we'll have unbounded execution time for e.g.
-+				 *  /()*x/.exec('x').  We can't just skip the match because it might have some
-+				 *  side effects (for instance, if we allowed captures in simple atoms, the
-+				 *  capture needs to happen).  The simple solution below is to force the
-+				 *  quantifier to match at most once, since the additional matches have no effect.
-+				 *
-+				 *  With a simple atom there can be no capture groups, so no captures need
-+				 *  to be reset.
-+				 */
-+				duk_int32_t atom_code_length;
-+				duk_uint32_t offset;
-+				duk_uint32_t qmin, qmax;
-+
-+				qmin = re_ctx->curr_token.qmin;
-+				qmax = re_ctx->curr_token.qmax;
-+				if (atom_char_length == 0) {
-+					/* qmin and qmax will be 0 or 1 */
-+					if (qmin > 1) {
-+						qmin = 1;
-+					}
-+					if (qmax > 1) {
-+						qmax = 1;
-+					}
-+				}
-+
-+				duk__append_u32(re_ctx, DUK_REOP_MATCH);   /* complete 'sub atom' */
-+				atom_code_length = (duk_int32_t) (DUK__BUFLEN(re_ctx) - atom_start_offset);
-+
-+				offset = atom_start_offset;
-+				if (re_ctx->curr_token.greedy) {
-+					offset += duk__insert_u32(re_ctx, offset, DUK_REOP_SQGREEDY);
-+					offset += duk__insert_u32(re_ctx, offset, qmin);
-+					offset += duk__insert_u32(re_ctx, offset, qmax);
-+					offset += duk__insert_u32(re_ctx, offset, atom_char_length);
-+					offset += duk__insert_jump_offset(re_ctx, offset, atom_code_length);
-+				} else {
-+					offset += duk__insert_u32(re_ctx, offset, DUK_REOP_SQMINIMAL);
-+					offset += duk__insert_u32(re_ctx, offset, qmin);
-+					offset += duk__insert_u32(re_ctx, offset, qmax);
-+					offset += duk__insert_jump_offset(re_ctx, offset, atom_code_length);
-+				}
-+				DUK_UNREF(offset);  /* silence scan-build warning */
-+			} else {
-+				/*
-+				 *  Complex atom
-+				 *
-+				 *  The original code is used as a template, and removed at the end
-+				 *  (this differs from the handling of simple quantifiers).
-+				 *
-+				 *  NOTE: there is no current solution for empty atoms in complex
-+				 *  quantifiers.  This would need some sort of a 'progress' instruction.
-+				 *
-+				 *  XXX: impose limit on maximum result size, i.e. atom_code_len * atom_copies?
-+				 */
-+				duk_int32_t atom_code_length;
-+				duk_uint32_t atom_copies;
-+				duk_uint32_t tmp_qmin, tmp_qmax;
-+
-+				/* pre-check how many atom copies we're willing to make (atom_copies not needed below) */
-+				atom_copies = (re_ctx->curr_token.qmax == DUK_RE_QUANTIFIER_INFINITE) ?
-+				              re_ctx->curr_token.qmin : re_ctx->curr_token.qmax;
-+				if (atom_copies > DUK_RE_MAX_ATOM_COPIES) {
-+					DUK_ERROR(re_ctx->thr, DUK_ERR_RANGE_ERROR,
-+					          DUK_STR_QUANTIFIER_TOO_MANY_COPIES);
-+				}
-+
-+				/* wipe the capture range made by the atom (if any) */
-+				DUK_ASSERT(atom_start_captures <= re_ctx->captures);
-+				if (atom_start_captures != re_ctx->captures) {
-+					DUK_ASSERT(atom_start_captures < re_ctx->captures);
-+					DUK_DDD(DUK_DDDPRINT("must wipe ]atom_start_captures,re_ctx->captures]: ]%ld,%ld]",
-+					                     (long) atom_start_captures, (long) re_ctx->captures));
-+
-+					/* insert (DUK_REOP_WIPERANGE, start, count) in reverse order so the order ends up right */
-+					duk__insert_u32(re_ctx, atom_start_offset, (re_ctx->captures - atom_start_captures) * 2);
-+					duk__insert_u32(re_ctx, atom_start_offset, (atom_start_captures + 1) * 2);
-+					duk__insert_u32(re_ctx, atom_start_offset, DUK_REOP_WIPERANGE);
-+				} else {
-+					DUK_DDD(DUK_DDDPRINT("no need to wipe captures: atom_start_captures == re_ctx->captures == %ld",
-+					                     (long) atom_start_captures));
-+				}
-+
-+				atom_code_length = (duk_int32_t) DUK__BUFLEN(re_ctx) - atom_start_offset;
-+
-+				/* insert the required matches (qmin) by copying the atom */
-+				tmp_qmin = re_ctx->curr_token.qmin;
-+				tmp_qmax = re_ctx->curr_token.qmax;
-+				while (tmp_qmin > 0) {
-+					duk__append_slice(re_ctx, atom_start_offset, atom_code_length);
-+					tmp_qmin--;
-+					if (tmp_qmax != DUK_RE_QUANTIFIER_INFINITE) {
-+						tmp_qmax--;
-+					}
-+				}
-+				DUK_ASSERT(tmp_qmin == 0);
-+
-+				/* insert code for matching the remainder - infinite or finite */
-+				if (tmp_qmax == DUK_RE_QUANTIFIER_INFINITE) {
-+					/* reuse last emitted atom for remaining 'infinite' quantifier */
-+
-+					if (re_ctx->curr_token.qmin == 0) {
-+						/* Special case: original qmin was zero so there is nothing
-+						 * to repeat.  Emit an atom copy but jump over it here.
-+						 */
-+						duk__append_u32(re_ctx, DUK_REOP_JUMP);
-+						duk__append_jump_offset(re_ctx, atom_code_length);
-+						duk__append_slice(re_ctx, atom_start_offset, atom_code_length);
-+					}
-+					if (re_ctx->curr_token.greedy) {
-+						duk__append_u32(re_ctx, DUK_REOP_SPLIT2);   /* prefer jump */
-+					} else {
-+						duk__append_u32(re_ctx, DUK_REOP_SPLIT1);   /* prefer direct */
-+					}
-+					duk__append_jump_offset(re_ctx, -atom_code_length - 1);  /* -1 for opcode */
-+				} else {
-+					/*
-+					 *  The remaining matches are emitted as sequence of SPLITs and atom
-+					 *  copies; the SPLITs skip the remaining copies and match the sequel.
-+					 *  This sequence needs to be emitted starting from the last copy
-+					 *  because the SPLITs are variable length due to the variable length
-+					 *  skip offset.  This causes a lot of memory copying now.
-+					 *
-+					 *  Example structure (greedy, match maximum # atoms):
-+					 *
-+					 *      SPLIT1 LSEQ
-+					 *      (atom)
-+					 *      SPLIT1 LSEQ    ; <- the byte length of this instruction is needed
-+					 *      (atom)         ; to encode the above SPLIT1 correctly
-+					 *      ...
-+					 *   LSEQ:
-+					 */
-+					duk_uint32_t offset = (duk_uint32_t) DUK__BUFLEN(re_ctx);
-+					while (tmp_qmax > 0) {
-+						duk__insert_slice(re_ctx, offset, atom_start_offset, atom_code_length);
-+						if (re_ctx->curr_token.greedy) {
-+							duk__insert_u32(re_ctx, offset, DUK_REOP_SPLIT1);   /* prefer direct */
-+						} else {
-+							duk__insert_u32(re_ctx, offset, DUK_REOP_SPLIT2);   /* prefer jump */
-+						}
-+						duk__insert_jump_offset(re_ctx,
-+						                        offset + 1,   /* +1 for opcode */
-+						                        (duk_int32_t) (DUK__BUFLEN(re_ctx) - (offset + 1)));
-+						tmp_qmax--;
-+					}
-+				}
-+
-+				/* remove the original 'template' atom */
-+				duk__remove_slice(re_ctx, atom_start_offset, atom_code_length);
-+			}
-+
-+			/* 'taint' result as complex */
-+			res_charlen = -1;
-+			break;
-+		}
-+		case DUK_RETOK_ASSERT_START: {
-+			duk__append_u32(re_ctx, DUK_REOP_ASSERT_START);
-+			break;
-+		}
-+		case DUK_RETOK_ASSERT_END: {
-+			duk__append_u32(re_ctx, DUK_REOP_ASSERT_END);
-+			break;
-+		}
-+		case DUK_RETOK_ASSERT_WORD_BOUNDARY: {
-+			duk__append_u32(re_ctx, DUK_REOP_ASSERT_WORD_BOUNDARY);
-+			break;
-+		}
-+		case DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY: {
-+			duk__append_u32(re_ctx, DUK_REOP_ASSERT_NOT_WORD_BOUNDARY);
-+			break;
-+		}
-+		case DUK_RETOK_ASSERT_START_POS_LOOKAHEAD:
-+		case DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD: {
-+			duk_uint32_t offset;
-+			duk_uint32_t opcode = (re_ctx->curr_token.t == DUK_RETOK_ASSERT_START_POS_LOOKAHEAD) ?
-+			                      DUK_REOP_LOOKPOS : DUK_REOP_LOOKNEG;
-+
-+			offset = (duk_uint32_t) DUK__BUFLEN(re_ctx);
-+			duk__parse_disjunction(re_ctx, 0, &tmp_disj);
-+			duk__append_u32(re_ctx, DUK_REOP_MATCH);
-+
-+			(void) duk__insert_u32(re_ctx, offset, opcode);
-+			(void) duk__insert_jump_offset(re_ctx,
-+			                               offset + 1,   /* +1 for opcode */
-+			                               (duk_int32_t) (DUK__BUFLEN(re_ctx) - (offset + 1)));
-+
-+			/* 'taint' result as complex -- this is conservative,
-+			 * as lookaheads do not backtrack.
-+			 */
-+			res_charlen = -1;
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_PERIOD: {
-+			new_atom_char_length = 1;
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			duk__append_u32(re_ctx, DUK_REOP_PERIOD);
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_CHAR: {
-+			/* Note: successive characters could be joined into string matches
-+			 * but this is not trivial (consider e.g. '/xyz+/); see docs for
-+			 * more discussion.
-+			 */
-+			duk_uint32_t ch;
-+
-+			new_atom_char_length = 1;
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			duk__append_u32(re_ctx, DUK_REOP_CHAR);
-+			ch = re_ctx->curr_token.num;
-+			if (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) {
-+				ch = duk_unicode_re_canonicalize_char(re_ctx->thr, ch);
-+			}
-+			duk__append_u32(re_ctx, ch);
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_DIGIT:
-+		case DUK_RETOK_ATOM_NOT_DIGIT: {
-+			new_atom_char_length = 1;
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			duk__append_u32(re_ctx,
-+			                (re_ctx->curr_token.t == DUK_RETOK_ATOM_DIGIT) ?
-+			                DUK_REOP_RANGES : DUK_REOP_INVRANGES);
-+			duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_digit) / (2 * sizeof(duk_uint16_t)));
-+			duk__append_u16_list(re_ctx, duk_unicode_re_ranges_digit, sizeof(duk_unicode_re_ranges_digit) / sizeof(duk_uint16_t));
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_WHITE:
-+		case DUK_RETOK_ATOM_NOT_WHITE: {
-+			new_atom_char_length = 1;
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			duk__append_u32(re_ctx,
-+			                (re_ctx->curr_token.t == DUK_RETOK_ATOM_WHITE) ?
-+			                DUK_REOP_RANGES : DUK_REOP_INVRANGES);
-+			duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_white) / (2 * sizeof(duk_uint16_t)));
-+			duk__append_u16_list(re_ctx, duk_unicode_re_ranges_white, sizeof(duk_unicode_re_ranges_white) / sizeof(duk_uint16_t));
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_WORD_CHAR:
-+		case DUK_RETOK_ATOM_NOT_WORD_CHAR: {
-+			new_atom_char_length = 1;
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			duk__append_u32(re_ctx,
-+			                (re_ctx->curr_token.t == DUK_RETOK_ATOM_WORD_CHAR) ?
-+			                DUK_REOP_RANGES : DUK_REOP_INVRANGES);
-+			duk__append_u32(re_ctx, sizeof(duk_unicode_re_ranges_wordchar) / (2 * sizeof(duk_uint16_t)));
-+			duk__append_u16_list(re_ctx, duk_unicode_re_ranges_wordchar, sizeof(duk_unicode_re_ranges_wordchar) / sizeof(duk_uint16_t));
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_BACKREFERENCE: {
-+			duk_uint32_t backref = (duk_uint32_t) re_ctx->curr_token.num;
-+			if (backref > re_ctx->highest_backref) {
-+				re_ctx->highest_backref = backref;
-+			}
-+			new_atom_char_length = -1;   /* mark as complex */
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			duk__append_u32(re_ctx, DUK_REOP_BACKREFERENCE);
-+			duk__append_u32(re_ctx, backref);
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_START_CAPTURE_GROUP: {
-+			duk_uint32_t cap;
-+
-+			new_atom_char_length = -1;   /* mark as complex (capture handling) */
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			cap = ++re_ctx->captures;
-+			duk__append_u32(re_ctx, DUK_REOP_SAVE);
-+			duk__append_u32(re_ctx, cap * 2);
-+			duk__parse_disjunction(re_ctx, 0, &tmp_disj);  /* retval (sub-atom char length) unused, tainted as complex above */
-+			duk__append_u32(re_ctx, DUK_REOP_SAVE);
-+			duk__append_u32(re_ctx, cap * 2 + 1);
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_START_NONCAPTURE_GROUP: {
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			duk__parse_disjunction(re_ctx, 0, &tmp_disj);
-+			new_atom_char_length = tmp_disj.charlen;
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_START_CHARCLASS:
-+		case DUK_RETOK_ATOM_START_CHARCLASS_INVERTED: {
-+			/*
-+			 *  Range parsing is done with a special lexer function which calls
-+			 *  us for every range parsed.  This is different from how rest of
-+			 *  the parsing works, but avoids a heavy, arbitrary size intermediate
-+			 *  value type to hold the ranges.
-+			 *
-+			 *  Another complication is the handling of character ranges when
-+			 *  case insensitive matching is used (see docs for discussion).
-+			 *  The range handler callback given to the lexer takes care of this
-+			 *  as well.
-+			 *
-+			 *  Note that duplicate ranges are not eliminated when parsing character
-+			 *  classes, so that canonicalization of
-+			 *
-+			 *    [0-9a-fA-Fx-{]
-+			 *
-+			 *  creates the result (note the duplicate ranges):
-+			 *
-+			 *    [0-9A-FA-FX-Z{-{]
-+			 *
-+			 *  where [x-{] is split as a result of canonicalization.  The duplicate
-+			 *  ranges are not a semantics issue: they work correctly.
-+			 */
-+
-+			duk_uint32_t offset;
-+
-+			DUK_DD(DUK_DDPRINT("character class"));
-+
-+			/* insert ranges instruction, range count patched in later */
-+			new_atom_char_length = 1;
-+			new_atom_start_offset = (duk_int32_t) DUK__BUFLEN(re_ctx);
-+			duk__append_u32(re_ctx,
-+			                (re_ctx->curr_token.t == DUK_RETOK_ATOM_START_CHARCLASS) ?
-+			                DUK_REOP_RANGES : DUK_REOP_INVRANGES);
-+			offset = (duk_uint32_t) DUK__BUFLEN(re_ctx);    /* patch in range count later */
-+
-+			/* parse ranges until character class ends */
-+			re_ctx->nranges = 0;    /* note: ctx-wide temporary */
-+			duk_lexer_parse_re_ranges(&re_ctx->lex, duk__generate_ranges, (void *) re_ctx);
-+
-+			/* insert range count */
-+			duk__insert_u32(re_ctx, offset, re_ctx->nranges);
-+			break;
-+		}
-+		case DUK_RETOK_ATOM_END_GROUP: {
-+			if (expect_eof) {
-+				DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+				          DUK_STR_UNEXPECTED_CLOSING_PAREN);
-+			}
-+			goto done;
-+		}
-+		case DUK_RETOK_EOF: {
-+			if (!expect_eof) {
-+				DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+				          DUK_STR_UNEXPECTED_END_OF_PATTERN);
-+			}
-+			goto done;
-+		}
-+		default: {
-+			DUK_ERROR(re_ctx->thr, DUK_ERR_SYNTAX_ERROR,
-+			          DUK_STR_UNEXPECTED_REGEXP_TOKEN);
-+		}
-+		}
-+
-+		/* a complex (new) atom taints the result */
-+		if (new_atom_start_offset >= 0) {
-+			if (new_atom_char_length < 0) {
-+				res_charlen = -1;
-+			} else if (res_charlen >= 0) {
-+				/* only advance if not tainted */
-+				res_charlen += new_atom_char_length;
-+			}
-+		}
-+
-+		/* record previous atom info in case next token is a quantifier */
-+		atom_start_offset = new_atom_start_offset;
-+		atom_char_length = new_atom_char_length;
-+		atom_start_captures = new_atom_start_captures;
-+	}
-+
-+ done:
-+
-+	/* finish up pending jump and split for last alternative */
-+	if (unpatched_disjunction_jump >= 0) {
-+		duk_uint32_t offset;
-+
-+		DUK_ASSERT(unpatched_disjunction_split >= 0);
-+		offset = unpatched_disjunction_jump;
-+		offset += duk__insert_jump_offset(re_ctx,
-+		                                  offset,
-+		                                  (duk_int32_t) (DUK__BUFLEN(re_ctx) - offset));
-+		/* offset is now target of the pending split (right after jump) */
-+		duk__insert_jump_offset(re_ctx,
-+		                        unpatched_disjunction_split,
-+		                        offset - unpatched_disjunction_split);
-+	}
-+
-+#if 0
-+	out_atom_info->end_captures = re_ctx->captures;
-+#endif
-+	out_atom_info->charlen = res_charlen;
-+	DUK_DDD(DUK_DDDPRINT("parse disjunction finished: charlen=%ld",
-+	                     (long) out_atom_info->charlen));
-+
-+	re_ctx->recursion_depth--;
-+}
-+
-+/*
-+ *  Flags parsing (see E5 Section 15.10.4.1).
-+ */
-+
-+DUK_LOCAL duk_uint32_t duk__parse_regexp_flags(duk_hthread *thr, duk_hstring *h) {
-+	const duk_uint8_t *p;
-+	const duk_uint8_t *p_end;
-+	duk_uint32_t flags = 0;
-+
-+	p = DUK_HSTRING_GET_DATA(h);
-+	p_end = p + DUK_HSTRING_GET_BYTELEN(h);
-+
-+	/* Note: can be safely scanned as bytes (undecoded) */
-+
-+	while (p < p_end) {
-+		duk_uint8_t c = *p++;
-+		switch ((int) c) {
-+		case (int) 'g': {
-+			if (flags & DUK_RE_FLAG_GLOBAL) {
-+				goto error;
-+			}
-+			flags |= DUK_RE_FLAG_GLOBAL;
-+			break;
-+		}
-+		case (int) 'i': {
-+			if (flags & DUK_RE_FLAG_IGNORE_CASE) {
-+				goto error;
-+			}
-+			flags |= DUK_RE_FLAG_IGNORE_CASE;
-+			break;
-+		}
-+		case (int) 'm': {
-+			if (flags & DUK_RE_FLAG_MULTILINE) {
-+				goto error;
-+			}
-+			flags |= DUK_RE_FLAG_MULTILINE;
-+			break;
-+		}
-+		default: {
-+			goto error;
-+		}
-+		}
-+	}
-+
-+	return flags;
-+
-+ error:
-+	DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_REGEXP_FLAGS);
-+	return 0;  /* never here */
-+}
-+
-+/*
-+ *  Create escaped RegExp source (E5 Section 15.10.3).
-+ *
-+ *  The current approach is to special case the empty RegExp
-+ *  ('' -> '(?:)') and otherwise replace unescaped '/' characters
-+ *  with '\/' regardless of where they occur in the regexp.
-+ *
-+ *  Note that normalization does not seem to be necessary for
-+ *  RegExp literals (e.g. '/foo/') because to be acceptable as
-+ *  a RegExp literal, the text between forward slashes must
-+ *  already match the escaping requirements (e.g. must not contain
-+ *  unescaped forward slashes or be empty).  Escaping IS needed
-+ *  for expressions like 'new Regexp("...", "")' however.
-+ *  Currently, we re-escape in either case.
-+ *
-+ *  Also note that we process the source here in UTF-8 encoded
-+ *  form.  This is correct, because any non-ASCII characters are
-+ *  passed through without change.
-+ */
-+
-+DUK_LOCAL void duk__create_escaped_source(duk_hthread *thr, int idx_pattern) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hstring *h;
-+	duk_hbuffer_dynamic *buf;
-+	const duk_uint8_t *p;
-+	duk_size_t i, n;
-+	duk_uint_fast8_t c_prev, c;
-+
-+	h = duk_get_hstring(ctx, idx_pattern);
-+	DUK_ASSERT(h != NULL);
-+	p = (const duk_uint8_t *) DUK_HSTRING_GET_DATA(h);
-+	n = (duk_size_t) DUK_HSTRING_GET_BYTELEN(h);
-+
-+	if (n == 0) {
-+		/* return '(?:)' */
-+		duk_push_hstring_stridx(ctx, DUK_STRIDX_ESCAPED_EMPTY_REGEXP);
-+		return;
-+	}
-+
-+	duk_push_dynamic_buffer(ctx, 0);
-+	buf = (duk_hbuffer_dynamic *) duk_get_hbuffer(ctx, -1);
-+	DUK_ASSERT(buf != NULL);
-+
-+	c_prev = (duk_uint_fast8_t) 0;
-+
-+	for (i = 0; i < n; i++) {
-+		c = p[i];
-+
-+		if (c == (duk_uint_fast8_t) '/' && c_prev != (duk_uint_fast8_t) '\\') {
-+			/* Unescaped '/' ANYWHERE in the regexp (in disjunction,
-+			 * inside a character class, ...) => same escape works.
-+			 */
-+			duk_hbuffer_append_byte(thr, buf, (duk_uint8_t) '\\');
-+		}
-+		duk_hbuffer_append_byte(thr, buf, (duk_uint8_t) c);
-+
-+		c_prev = c;
-+	}
-+
-+	duk_to_string(ctx, -1);  /* -> [ ... escaped_source ] */
-+}
-+
-+/*
-+ *  Exposed regexp compilation primitive.
-+ *
-+ *  Sets up a regexp compilation context, and calls duk__parse_disjunction() to do the
-+ *  actual parsing.  Handles generation of the compiled regexp header and the
-+ *  "boilerplate" capture of the matching substring (save 0 and 1).  Also does some
-+ *  global level regexp checks after recursive compilation has finished.
-+ *
-+ *  An escaped version of the regexp source, suitable for use as a RegExp instance
-+ *  'source' property (see E5 Section 15.10.3), is also left on the stack.
-+ *
-+ *  Input stack:  [ pattern flags ]
-+ *  Output stack: [ bytecode escaped_source ]  (both as strings)
-+ */
-+
-+DUK_INTERNAL void duk_regexp_compile(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_re_compiler_ctx re_ctx;
-+	duk_lexer_point lex_point;
-+	duk_hstring *h_pattern;
-+	duk_hstring *h_flags;
-+	duk_hbuffer_dynamic *h_buffer;
-+	duk__re_disjunction_info ign_disj;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+
-+	/*
-+	 *  Args validation
-+	 */
-+
-+	/* TypeError if fails */
-+	h_pattern = duk_require_hstring(ctx, -2);
-+	h_flags = duk_require_hstring(ctx, -1);
-+
-+	/*
-+	 *  Create normalized 'source' property (E5 Section 15.10.3).
-+	 */
-+
-+	/* [ ... pattern flags ] */
-+
-+	duk__create_escaped_source(thr, -2);
-+
-+	/* [ ... pattern flags escaped_source ] */
-+
-+	/*
-+	 *  Init compilation context
-+	 */
-+
-+	duk_push_dynamic_buffer(ctx, 0);
-+	h_buffer = (duk_hbuffer_dynamic *) duk_require_hbuffer(ctx, -1);
-+	DUK_ASSERT(DUK_HBUFFER_HAS_DYNAMIC(h_buffer));
-+
-+	/* [ ... pattern flags escaped_source buffer ] */
-+
-+	DUK_MEMZERO(&re_ctx, sizeof(re_ctx));
-+	DUK_LEXER_INITCTX(&re_ctx.lex);  /* duplicate zeroing, expect for (possible) NULL inits */
-+	re_ctx.thr = thr;
-+	re_ctx.lex.thr = thr;
-+	re_ctx.lex.input = DUK_HSTRING_GET_DATA(h_pattern);
-+	re_ctx.lex.input_length = DUK_HSTRING_GET_BYTELEN(h_pattern);
-+	re_ctx.lex.token_limit = DUK_RE_COMPILE_TOKEN_LIMIT;
-+	re_ctx.buf = h_buffer;
-+	re_ctx.recursion_limit = DUK_RE_COMPILE_RECURSION_LIMIT;
-+	re_ctx.re_flags = duk__parse_regexp_flags(thr, h_flags);
-+
-+	DUK_DD(DUK_DDPRINT("regexp compiler ctx initialized, flags=0x%08lx, recursion_limit=%ld",
-+	                   (unsigned long) re_ctx.re_flags, (long) re_ctx.recursion_limit));
-+
-+	/*
-+	 *  Init lexer
-+	 */
-+
-+	lex_point.offset = 0;  /* expensive init, just want to fill window */
-+	lex_point.line = 1;
-+	DUK_LEXER_SETPOINT(&re_ctx.lex, &lex_point);
-+
-+	/*
-+	 *  Compilation
-+	 */
-+
-+	DUK_D(DUK_DPRINT("starting regexp compilation"));
-+
-+	duk__append_u32(&re_ctx, DUK_REOP_SAVE);
-+	duk__append_u32(&re_ctx, 0);
-+	duk__parse_disjunction(&re_ctx, 1 /*expect_eof*/, &ign_disj);
-+	duk__append_u32(&re_ctx, DUK_REOP_SAVE);
-+	duk__append_u32(&re_ctx, 1);
-+	duk__append_u32(&re_ctx, DUK_REOP_MATCH);
-+
-+	DUK_D(DUK_DPRINT("regexp bytecode size (before header) is %ld bytes",
-+	                 (long) DUK_HBUFFER_GET_SIZE(re_ctx.buf)));
-+
-+	/*
-+	 *  Check for invalid backreferences; note that it is NOT an error
-+	 *  to back-reference a capture group which has not yet been introduced
-+	 *  in the pattern (as in /\1(foo)/); in fact, the backreference will
-+	 *  always match!  It IS an error to back-reference a capture group
-+	 *  which will never be introduced in the pattern.  Thus, we can check
-+	 *  for such references only after parsing is complete.
-+	 */
-+
-+	if (re_ctx.highest_backref > re_ctx.captures) {
-+		DUK_ERROR(thr, DUK_ERR_SYNTAX_ERROR, DUK_STR_INVALID_BACKREFS);
-+	}
-+
-+	/*
-+	 *  Emit compiled regexp header: flags, ncaptures
-+	 *  (insertion order inverted on purpose)
-+	 */
-+
-+	duk__insert_u32(&re_ctx, 0, (re_ctx.captures + 1) * 2);
-+	duk__insert_u32(&re_ctx, 0, re_ctx.re_flags);
-+
-+	DUK_D(DUK_DPRINT("regexp bytecode size (after header) is %ld bytes",
-+	                 (long) DUK_HBUFFER_GET_SIZE(re_ctx.buf)));
-+	DUK_DDD(DUK_DDDPRINT("compiled regexp: %!xO", (duk_heaphdr *) re_ctx.buf));
-+
-+	/* [ ... pattern flags escaped_source buffer ] */
-+
-+	duk_to_string(ctx, -1);  /* coerce to string */
-+
-+	/* [ ... pattern flags escaped_source bytecode ] */
-+
-+	/*
-+	 *  Finalize stack
-+	 */
-+
-+	duk_remove(ctx, -4);     /* -> [ ... flags escaped_source bytecode ] */
-+	duk_remove(ctx, -3);     /* -> [ ... escaped_source bytecode ] */
-+
-+	DUK_D(DUK_DPRINT("regexp compilation successful, bytecode: %!T, escaped source: %!T",
-+	                 (duk_tval *) duk_get_tval(ctx, -1), (duk_tval *) duk_get_tval(ctx, -2)));
-+}
-+
-+/*
-+ *  Create a RegExp instance (E5 Section 15.10.7).
-+ *
-+ *  Note: the output stack left by duk_regexp_compile() is directly compatible
-+ *  with the input here.
-+ *
-+ *  Input stack:  [ escaped_source bytecode ]  (both as strings)
-+ *  Output stack: [ RegExp ]
-+ */
-+
-+DUK_INTERNAL void duk_regexp_create_instance(duk_hthread *thr) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_hobject *h;
-+	duk_hstring *h_bc;
-+	duk_small_int_t re_flags;
-+
-+	/* [ ... escape_source bytecode ] */
-+
-+	h_bc = duk_get_hstring(ctx, -1);
-+	DUK_ASSERT(h_bc != NULL);
-+	DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1);          /* always at least the header */
-+	DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1);
-+	DUK_ASSERT((duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80);  /* flags always encodes to 1 byte */
-+	re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
-+
-+	/* [ ... escaped_source bytecode ] */
-+
-+	duk_push_object(ctx);
-+	h = duk_get_hobject(ctx, -1);
-+	DUK_ASSERT(h != NULL);
-+	duk_insert(ctx, -3);
-+
-+	/* [ ... regexp_object escaped_source bytecode ] */
-+
-+	DUK_HOBJECT_SET_CLASS_NUMBER(h, DUK_HOBJECT_CLASS_REGEXP);
-+	DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[DUK_BIDX_REGEXP_PROTOTYPE]);
-+
-+	duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_BYTECODE, DUK_PROPDESC_FLAGS_NONE);
-+
-+	/* [ ... regexp_object escaped_source ] */
-+
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_SOURCE, DUK_PROPDESC_FLAGS_NONE);
-+
-+	/* [ ... regexp_object ] */
-+
-+	duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_GLOBAL));
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_GLOBAL, DUK_PROPDESC_FLAGS_NONE);
-+
-+	duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_IGNORE_CASE));
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_IGNORE_CASE, DUK_PROPDESC_FLAGS_NONE);
-+
-+	duk_push_boolean(ctx, (re_flags & DUK_RE_FLAG_MULTILINE));
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_MULTILINE, DUK_PROPDESC_FLAGS_NONE);
-+
-+	duk_push_int(ctx, 0);
-+	duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_LAST_INDEX, DUK_PROPDESC_FLAGS_W);
-+
-+	/* [ ... regexp_object ] */
-+}
-+
-+#undef DUK__BUFLEN
-+
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+
-+/* regexp support disabled */
-+
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+#line 1 "duk_regexp_executor.c"
-+/*
-+ *  Regexp executor.
-+ *
-+ *  Safety: the Ecmascript executor should prevent user from reading and
-+ *  replacing regexp bytecode.  Even so, the executor must validate all
-+ *  memory accesses etc.  When an invalid access is detected (e.g. a 'save'
-+ *  opcode to invalid, unallocated index) it should fail with an internal
-+ *  error but not cause a segmentation fault.
-+ *
-+ *  Notes:
-+ *
-+ *    - Backtrack counts are limited to unsigned 32 bits but should
-+ *      technically be duk_size_t for strings longer than 4G chars.
-+ *      This also requires a regexp bytecode change.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_REGEXP_SUPPORT
-+
-+/*
-+ *  Helpers for UTF-8 handling
-+ *
-+ *  For bytecode readers the duk_uint32_t and duk_int32_t types are correct
-+ *  because they're used for more than just codepoints.
-+ */
-+
-+DUK_LOCAL duk_uint32_t duk__bc_get_u32(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **pc) {
-+	return (duk_uint32_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, pc, re_ctx->bytecode, re_ctx->bytecode_end);
-+}
-+
-+DUK_LOCAL duk_int32_t duk__bc_get_i32(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **pc) {
-+	duk_uint32_t t;
-+
-+	/* signed integer encoding needed to work with UTF-8 */
-+	t = (duk_uint32_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, pc, re_ctx->bytecode, re_ctx->bytecode_end);
-+	if (t & 1) {
-+		return -((duk_int32_t) (t >> 1));
-+	} else {
-+		return (duk_int32_t) (t >> 1);
-+	}
-+}
-+
-+DUK_LOCAL const duk_uint8_t *duk__utf8_backtrack(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_uint_fast32_t count) {
-+	const duk_uint8_t *p;
-+
-+	/* Note: allow backtracking from p == ptr_end */
-+	p = *ptr;
-+	if (p < ptr_start || p > ptr_end) {
-+		goto fail;
-+	}
-+
-+	while (count > 0) {
-+		for (;;) {
-+			p--;
-+			if (p < ptr_start) {
-+				goto fail;
-+			}
-+			if ((*p & 0xc0) != 0x80) {
-+				/* utf-8 continuation bytes have the form 10xx xxxx */
-+				break;
-+			}
-+		}
-+		count--;
-+	}
-+	*ptr = p;
-+	return p;
-+
-+ fail:
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REGEXP_BACKTRACK_FAILED);
-+	return NULL;  /* never here */
-+}
-+
-+DUK_LOCAL const duk_uint8_t *duk__utf8_advance(duk_hthread *thr, const duk_uint8_t **ptr, const duk_uint8_t *ptr_start, const duk_uint8_t *ptr_end, duk_uint_fast32_t count) {
-+	const duk_uint8_t *p;
-+
-+	p = *ptr;
-+	if (p < ptr_start || p >= ptr_end) {
-+		goto fail;
-+	}
-+
-+	while (count > 0) {
-+		for (;;) {
-+			p++;
-+
-+			/* Note: if encoding ends by hitting end of input, we don't check that
-+			 * the encoding is valid, we just assume it is.
-+			 */
-+			if (p >= ptr_end || ((*p & 0xc0) != 0x80)) {
-+				/* utf-8 continuation bytes have the form 10xx xxxx */
-+				break;
-+			}
-+		}
-+		count--;
-+	}
-+
-+	*ptr = p;
-+	return p;
-+
-+ fail:
-+	DUK_ERROR(thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REGEXP_ADVANCE_FAILED);
-+	return NULL;  /* never here */
-+}
-+
-+/*
-+ *  Helpers for dealing with the input string
-+ */
-+
-+/* Get a (possibly canonicalized) input character from current sp.  The input
-+ * itself is never modified, and captures always record non-canonicalized
-+ * characters even in case-insensitive matching.
-+ */
-+DUK_LOCAL duk_codepoint_t duk__inp_get_cp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **sp) {
-+	duk_codepoint_t res = (duk_codepoint_t) duk_unicode_decode_xutf8_checked(re_ctx->thr, sp, re_ctx->input, re_ctx->input_end);
-+	if (re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) {
-+		res = duk_unicode_re_canonicalize_char(re_ctx->thr, res);
-+	}
-+	return res;
-+}
-+
-+DUK_LOCAL const duk_uint8_t *duk__inp_backtrack(duk_re_matcher_ctx *re_ctx, const duk_uint8_t **sp, duk_uint_fast32_t count) {
-+	return duk__utf8_backtrack(re_ctx->thr, sp, re_ctx->input, re_ctx->input_end, count);
-+}
-+
-+/* Backtrack utf-8 input and return a (possibly canonicalized) input character. */
-+DUK_LOCAL duk_codepoint_t duk__inp_get_prev_cp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t *sp) {
-+	/* note: caller 'sp' is intentionally not updated here */
-+	(void) duk__inp_backtrack(re_ctx, &sp, (duk_uint_fast32_t) 1);
-+	return duk__inp_get_cp(re_ctx, &sp);
-+}
-+
-+/*
-+ *  Regexp recursive matching function.
-+ *
-+ *  Returns 'sp' on successful match (points to character after last matched one),
-+ *  NULL otherwise.
-+ *
-+ *  The C recursion depth limit check is only performed in this function, this
-+ *  suffices because the function is present in all true recursion required by
-+ *  regexp execution.
-+ */
-+
-+DUK_LOCAL const duk_uint8_t *duk__match_regexp(duk_re_matcher_ctx *re_ctx, const duk_uint8_t *pc, const duk_uint8_t *sp) {
-+	if (re_ctx->recursion_depth >= re_ctx->recursion_limit) {
-+		DUK_ERROR(re_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT);
-+	}
-+	re_ctx->recursion_depth++;
-+
-+	for (;;) {
-+		duk_small_int_t op;
-+
-+		if (re_ctx->steps_count >= re_ctx->steps_limit) {
-+			DUK_ERROR(re_ctx->thr, DUK_ERR_RANGE_ERROR, DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT);
-+		}
-+		re_ctx->steps_count++;
-+
-+		op = (duk_small_int_t) duk__bc_get_u32(re_ctx, &pc);
-+
-+		DUK_DDD(DUK_DDDPRINT("match: rec=%ld, steps=%ld, pc (after op)=%ld, sp=%ld, op=%ld",
-+		                     (long) re_ctx->recursion_depth,
-+		                     (long) re_ctx->steps_count,
-+		                     (long) (pc - re_ctx->bytecode),
-+		                     (long) (sp - re_ctx->input),
-+		                     (long) op));
-+
-+		switch (op) {
-+		case DUK_REOP_MATCH: {
-+			goto match;
-+		}
-+		case DUK_REOP_CHAR: {
-+			/*
-+			 *  Byte-based matching would be possible for case-sensitive
-+			 *  matching but not for case-insensitive matching.  So, we
-+			 *  match by decoding the input and bytecode character normally.
-+			 *
-+			 *  Bytecode characters are assumed to be already canonicalized.
-+			 *  Input characters are canonicalized automatically by
-+			 *  duk__inp_get_cp() if necessary.
-+			 *
-+			 *  There is no opcode for matching multiple characters.  The
-+			 *  regexp compiler has trouble joining strings efficiently
-+			 *  during compilation.  See doc/regexp.txt for more discussion.
-+			 */
-+			duk_codepoint_t c1, c2;
-+
-+			c1 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
-+			DUK_ASSERT(!(re_ctx->re_flags & DUK_RE_FLAG_IGNORE_CASE) ||
-+			           c1 == duk_unicode_re_canonicalize_char(re_ctx->thr, c1));  /* canonicalized by compiler */
-+			if (sp >= re_ctx->input_end) {
-+				goto fail;
-+			}
-+			c2 = duk__inp_get_cp(re_ctx, &sp);
-+			DUK_DDD(DUK_DDDPRINT("char match, c1=%ld, c2=%ld", (long) c1, (long) c2));
-+			if (c1 != c2) {
-+				goto fail;
-+			}
-+			break;
-+		}
-+		case DUK_REOP_PERIOD: {
-+			duk_codepoint_t c;
-+
-+			if (sp >= re_ctx->input_end) {
-+				goto fail;
-+			}
-+			c = duk__inp_get_cp(re_ctx, &sp);
-+			if (duk_unicode_is_line_terminator(c)) {
-+				/* E5 Sections 15.10.2.8, 7.3 */
-+				goto fail;
-+			}
-+			break;
-+		}
-+		case DUK_REOP_RANGES:
-+		case DUK_REOP_INVRANGES: {
-+			duk_uint32_t n;
-+			duk_codepoint_t c;
-+			duk_small_int_t match;
-+
-+			n = duk__bc_get_u32(re_ctx, &pc);
-+			if (sp >= re_ctx->input_end) {
-+				goto fail;
-+			}
-+			c = duk__inp_get_cp(re_ctx, &sp);
-+
-+			match = 0;
-+			while (n) {
-+				duk_codepoint_t r1, r2;
-+				r1 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
-+				r2 = (duk_codepoint_t) duk__bc_get_u32(re_ctx, &pc);
-+				DUK_DDD(DUK_DDDPRINT("matching ranges/invranges, n=%ld, r1=%ld, r2=%ld, c=%ld",
-+				                     (long) n, (long) r1, (long) r2, (long) c));
-+				if (c >= r1 && c <= r2) {
-+					/* Note: don't bail out early, we must read all the ranges from
-+					 * bytecode.  Another option is to skip them efficiently after
-+					 * breaking out of here.  Prefer smallest code.
-+					 */
-+					match = 1;
-+				}
-+				n--;
-+			}
-+
-+			if (op == DUK_REOP_RANGES) {
-+				if (!match) {
-+					goto fail;
-+				}
-+			} else {
-+				DUK_ASSERT(op == DUK_REOP_INVRANGES);
-+				if (match) {
-+					goto fail;
-+				}
-+			}
-+			break;
-+		}
-+		case DUK_REOP_ASSERT_START: {
-+			duk_codepoint_t c;
-+
-+			if (sp <= re_ctx->input) {
-+				break;
-+			}
-+			if (!(re_ctx->re_flags & DUK_RE_FLAG_MULTILINE)) {
-+				goto fail;
-+			}
-+			c = duk__inp_get_prev_cp(re_ctx, sp);
-+			if (duk_unicode_is_line_terminator(c)) {
-+				/* E5 Sections 15.10.2.8, 7.3 */
-+				break;
-+			}
-+			goto fail;
-+		}
-+		case DUK_REOP_ASSERT_END: {
-+			duk_codepoint_t c;
-+			const duk_uint8_t *tmp_sp;
-+
-+			if (sp >= re_ctx->input_end) {
-+				break;
-+			}
-+			if (!(re_ctx->re_flags & DUK_RE_FLAG_MULTILINE)) {
-+				goto fail;
-+			}
-+			tmp_sp = sp;
-+			c = duk__inp_get_cp(re_ctx, &tmp_sp);
-+			if (duk_unicode_is_line_terminator(c)) {
-+				/* E5 Sections 15.10.2.8, 7.3 */
-+				break;
-+			}
-+			goto fail;
-+		}
-+		case DUK_REOP_ASSERT_WORD_BOUNDARY:
-+		case DUK_REOP_ASSERT_NOT_WORD_BOUNDARY: {
-+			/*
-+			 *  E5 Section 15.10.2.6.  The previous and current character
-+			 *  should -not- be canonicalized as they are now.  However,
-+			 *  canonicalization does not affect the result of IsWordChar()
-+			 *  (which depends on Unicode characters never canonicalizing
-+			 *  into ASCII characters) so this does not matter.
-+			 */
-+			duk_small_int_t w1, w2;
-+
-+			if (sp <= re_ctx->input) {
-+				w1 = 0;  /* not a wordchar */
-+			} else {
-+				duk_codepoint_t c;
-+				c = duk__inp_get_prev_cp(re_ctx, sp);
-+				w1 = duk_unicode_re_is_wordchar(c);
-+			}
-+			if (sp >= re_ctx->input_end) {
-+				w2 = 0;  /* not a wordchar */
-+			} else {
-+				const duk_uint8_t *tmp_sp = sp;  /* dummy so sp won't get updated */
-+				duk_codepoint_t c;
-+				c = duk__inp_get_cp(re_ctx, &tmp_sp);
-+				w2 = duk_unicode_re_is_wordchar(c);
-+			}
-+
-+			if (op == DUK_REOP_ASSERT_WORD_BOUNDARY) {
-+				if (w1 == w2) {
-+					goto fail;
-+				}
-+			} else {
-+				DUK_ASSERT(op == DUK_REOP_ASSERT_NOT_WORD_BOUNDARY);
-+				if (w1 != w2) {
-+					goto fail;
-+				}
-+			}
-+			break;
-+		}
-+		case DUK_REOP_JUMP: {
-+			duk_int32_t skip;
-+
-+			skip = duk__bc_get_i32(re_ctx, &pc);
-+			pc += skip;
-+			break;
-+		}
-+		case DUK_REOP_SPLIT1: {
-+			/* split1: prefer direct execution (no jump) */
-+			const duk_uint8_t *sub_sp;
-+			duk_int32_t skip;
-+
-+			skip = duk__bc_get_i32(re_ctx, &pc);
-+			sub_sp = duk__match_regexp(re_ctx, pc, sp);
-+			if (sub_sp) {
-+				sp = sub_sp;
-+				goto match;
-+			}
-+			pc += skip;
-+			break;
-+		}
-+		case DUK_REOP_SPLIT2: {
-+			/* split2: prefer jump execution (not direct) */
-+			const duk_uint8_t *sub_sp;
-+			duk_int32_t skip;
-+
-+			skip = duk__bc_get_i32(re_ctx, &pc);
-+			sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
-+			if (sub_sp) {
-+				sp = sub_sp;
-+				goto match;
-+			}
-+			break;
-+		}
-+		case DUK_REOP_SQMINIMAL: {
-+			duk_uint32_t q, qmin, qmax;
-+			duk_int32_t skip;
-+			const duk_uint8_t *sub_sp;
-+
-+			qmin = duk__bc_get_u32(re_ctx, &pc);
-+			qmax = duk__bc_get_u32(re_ctx, &pc);
-+			skip = duk__bc_get_i32(re_ctx, &pc);
-+			DUK_DDD(DUK_DDDPRINT("minimal quantifier, qmin=%lu, qmax=%lu, skip=%ld",
-+			                     (unsigned long) qmin, (unsigned long) qmax, (long) skip));
-+
-+			q = 0;
-+			while (q <= qmax) {
-+				if (q >= qmin) {
-+					sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
-+					if (sub_sp) {
-+						sp = sub_sp;
-+						goto match;
-+					}
-+				}
-+				sub_sp = duk__match_regexp(re_ctx, pc, sp);
-+				if (!sub_sp) {
-+					break;
-+				}
-+				sp = sub_sp;
-+				q++;
-+			}
-+			goto fail;
-+		}
-+		case DUK_REOP_SQGREEDY: {
-+			duk_uint32_t q, qmin, qmax, atomlen;
-+			duk_int32_t skip;
-+			const duk_uint8_t *sub_sp;
-+
-+			qmin = duk__bc_get_u32(re_ctx, &pc);
-+			qmax = duk__bc_get_u32(re_ctx, &pc);
-+			atomlen = duk__bc_get_u32(re_ctx, &pc);
-+			skip = duk__bc_get_i32(re_ctx, &pc);
-+			DUK_DDD(DUK_DDDPRINT("greedy quantifier, qmin=%lu, qmax=%lu, atomlen=%lu, skip=%ld",
-+			                     (unsigned long) qmin, (unsigned long) qmax, (unsigned long) atomlen, (long) skip));
-+
-+			q = 0;
-+			while (q < qmax) {
-+				sub_sp = duk__match_regexp(re_ctx, pc, sp);
-+				if (!sub_sp) {
-+					break;
-+				}
-+				sp = sub_sp;
-+				q++;
-+			}
-+			while (q >= qmin) {
-+				sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
-+				if (sub_sp) {
-+					sp = sub_sp;
-+					goto match;
-+				}
-+				if (q == qmin) {
-+					break;
-+				}
-+
-+				/* Note: if atom were to contain e.g. captures, we would need to
-+				 * re-match the atom to get correct captures.  Simply quantifiers
-+				 * do not allow captures in their atom now, so this is not an issue.
-+				 */
-+
-+				DUK_DDD(DUK_DDDPRINT("greedy quantifier, backtrack %ld characters (atomlen)",
-+				                     (long) atomlen));
-+				sp = duk__inp_backtrack(re_ctx, &sp, (duk_uint_fast32_t) atomlen);
-+				q--;
-+			}
-+			goto fail;
-+		}
-+		case DUK_REOP_SAVE: {
-+			duk_uint32_t idx;
-+			const duk_uint8_t *old;
-+			const duk_uint8_t *sub_sp;
-+
-+			idx = duk__bc_get_u32(re_ctx, &pc);
-+			if (idx >= re_ctx->nsaved) {
-+				/* idx is unsigned, < 0 check is not necessary */
-+				DUK_D(DUK_DPRINT("internal error, regexp save index insane: idx=%ld", (long) idx));
-+				goto internal_error;
-+			}
-+			old = re_ctx->saved[idx];
-+			re_ctx->saved[idx] = sp;
-+			sub_sp = duk__match_regexp(re_ctx, pc, sp);
-+			if (sub_sp) {
-+				sp = sub_sp;
-+				goto match;
-+			}
-+			re_ctx->saved[idx] = old;
-+			goto fail;
-+		}
-+		case DUK_REOP_WIPERANGE: {
-+			/* Wipe capture range and save old values for backtracking.
-+			 *
-+			 * XXX: this typically happens with a relatively small idx_count.
-+			 * It might be useful to handle cases where the count is small
-+			 * (say <= 8) by saving the values in stack instead.  This would
-+			 * reduce memory churn and improve performance, at the cost of a
-+			 * slightly higher code footprint.
-+			 */
-+			duk_uint32_t idx_start, idx_count;
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+			duk_uint32_t idx_end, idx;
-+#endif
-+			duk_uint8_t **range_save;
-+			const duk_uint8_t *sub_sp;
-+
-+			idx_start = duk__bc_get_u32(re_ctx, &pc);
-+			idx_count = duk__bc_get_u32(re_ctx, &pc);
-+			DUK_DDD(DUK_DDDPRINT("wipe saved range: start=%ld, count=%ld -> [%ld,%ld] (captures [%ld,%ld])",
-+			                     (long) idx_start, (long) idx_count,
-+			                     (long) idx_start, (long) (idx_start + idx_count - 1),
-+			                     (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
-+			if (idx_start + idx_count > re_ctx->nsaved || idx_count == 0) {
-+				/* idx is unsigned, < 0 check is not necessary */
-+				DUK_D(DUK_DPRINT("internal error, regexp wipe indices insane: idx_start=%ld, idx_count=%ld",
-+				                 (long) idx_start, (long) idx_count));
-+				goto internal_error;
-+			}
-+			DUK_ASSERT(idx_count > 0);
-+
-+			duk_require_stack((duk_context *) re_ctx->thr, 1);
-+			range_save = (duk_uint8_t **) duk_push_fixed_buffer((duk_context *) re_ctx->thr,
-+			                                                    sizeof(duk_uint8_t *) * idx_count);
-+			DUK_ASSERT(range_save != NULL);
-+			DUK_MEMCPY(range_save, re_ctx->saved + idx_start, sizeof(duk_uint8_t *) * idx_count);
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+			idx_end = idx_start + idx_count;
-+			for (idx = idx_start; idx < idx_end; idx++) {
-+				re_ctx->saved[idx] = NULL;
-+			}
-+#else
-+			DUK_MEMZERO((void *) (re_ctx->saved + idx_start), sizeof(duk_uint8_t *) * idx_count);
-+#endif
-+
-+			sub_sp = duk__match_regexp(re_ctx, pc, sp);
-+			if (sub_sp) {
-+				/* match: keep wiped/resaved values */
-+				DUK_DDD(DUK_DDDPRINT("match: keep wiped/resaved values [%ld,%ld] (captures [%ld,%ld])",
-+				                     (long) idx_start, (long) (idx_start + idx_count - 1),
-+			                             (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
-+				duk_pop((duk_context *) re_ctx->thr);
-+				sp = sub_sp;
-+				goto match;
-+			}
-+
-+			/* fail: restore saves */
-+			DUK_DDD(DUK_DDDPRINT("fail: restore wiped/resaved values [%ld,%ld] (captures [%ld,%ld])",
-+			                     (long) idx_start, (long) (idx_start + idx_count - 1),
-+			                     (long) (idx_start / 2), (long) ((idx_start + idx_count - 1) / 2)));
-+			DUK_MEMCPY((void *) (re_ctx->saved + idx_start),
-+			           (const void *) range_save,
-+			           sizeof(duk_uint8_t *) * idx_count);
-+			duk_pop((duk_context *) re_ctx->thr);
-+			goto fail;
-+		}
-+		case DUK_REOP_LOOKPOS:
-+		case DUK_REOP_LOOKNEG: {
-+			/*
-+			 *  Needs a save of multiple saved[] entries depending on what range
-+			 *  may be overwritten.  Because the regexp parser does no such analysis,
-+			 *  we currently save the entire saved array here.  Lookaheads are thus
-+			 *  a bit expensive.  Note that the saved array is not needed for just
-+			 *  the lookahead sub-match, but for the matching of the entire sequel.
-+			 *
-+			 *  The temporary save buffer is pushed on to the valstack to handle
-+			 *  errors correctly.  Each lookahead causes a C recursion and pushes
-+			 *  more stuff on the value stack.  If the C recursion limit is less
-+			 *  than the value stack spare, there is no need to check the stack.
-+			 *  We do so regardless, just in case.
-+			 */
-+
-+			duk_int32_t skip;
-+			duk_uint8_t **full_save;
-+			const duk_uint8_t *sub_sp;
-+
-+			DUK_ASSERT(re_ctx->nsaved > 0);
-+
-+			duk_require_stack((duk_context *) re_ctx->thr, 1);
-+			full_save = (duk_uint8_t **) duk_push_fixed_buffer((duk_context *) re_ctx->thr,
-+			                                                   sizeof(duk_uint8_t *) * re_ctx->nsaved);
-+			DUK_ASSERT(full_save != NULL);
-+			DUK_MEMCPY(full_save, re_ctx->saved, sizeof(duk_uint8_t *) * re_ctx->nsaved);
-+
-+			skip = duk__bc_get_i32(re_ctx, &pc);
-+			sub_sp = duk__match_regexp(re_ctx, pc, sp);
-+			if (op == DUK_REOP_LOOKPOS) {
-+				if (!sub_sp) {
-+					goto lookahead_fail;
-+				}
-+			} else {
-+				if (sub_sp) {
-+					goto lookahead_fail;
-+				}
-+			}
-+			sub_sp = duk__match_regexp(re_ctx, pc + skip, sp);
-+			if (sub_sp) {
-+				/* match: keep saves */
-+				duk_pop((duk_context *) re_ctx->thr);
-+				sp = sub_sp;
-+				goto match;
-+			}
-+
-+			/* fall through */
-+
-+		 lookahead_fail:
-+			/* fail: restore saves */
-+			DUK_MEMCPY((void *) re_ctx->saved,
-+			           (const void *) full_save,
-+			           sizeof(duk_uint8_t *) * re_ctx->nsaved);
-+			duk_pop((duk_context *) re_ctx->thr);
-+			goto fail;
-+		}
-+		case DUK_REOP_BACKREFERENCE: {
-+			/*
-+			 *  Byte matching for back-references would be OK in case-
-+			 *  sensitive matching.  In case-insensitive matching we need
-+			 *  to canonicalize characters, so back-reference matching needs
-+			 *  to be done with codepoints instead.  So, we just decode
-+			 *  everything normally here, too.
-+			 *
-+			 *  Note: back-reference index which is 0 or higher than
-+			 *  NCapturingParens (= number of capturing parens in the
-+			 *  -entire- regexp) is a compile time error.  However, a
-+			 *  backreference referring to a valid capture which has
-+			 *  not matched anything always succeeds!  See E5 Section
-+			 *  15.10.2.9, step 5, sub-step 3.
-+			 */
-+			duk_uint32_t idx;
-+			const duk_uint8_t *p;
-+
-+			idx = duk__bc_get_u32(re_ctx, &pc);
-+			idx = idx << 1;  /* backref n -> saved indices [n*2, n*2+1] */
-+			if (idx < 2 || idx + 1 >= re_ctx->nsaved) {
-+				/* regexp compiler should catch these */
-+				DUK_D(DUK_DPRINT("internal error, backreference index insane"));
-+				goto internal_error;
-+			}
-+			if (!re_ctx->saved[idx] || !re_ctx->saved[idx+1]) {
-+				/* capture is 'undefined', always matches! */
-+				DUK_DDD(DUK_DDDPRINT("backreference: saved[%ld,%ld] not complete, always match",
-+				                     (long) idx, (long) (idx + 1)));
-+				break;
-+			}
-+			DUK_DDD(DUK_DDDPRINT("backreference: match saved[%ld,%ld]", (long) idx, (long) (idx + 1)));
-+
-+			p = re_ctx->saved[idx];
-+			while (p < re_ctx->saved[idx+1]) {
-+				duk_codepoint_t c1, c2;
-+
-+				/* Note: not necessary to check p against re_ctx->input_end:
-+				 * the memory access is checked by duk__inp_get_cp(), while
-+				 * valid compiled regexps cannot write a saved[] entry
-+				 * which points to outside the string.
-+				 */
-+				if (sp >= re_ctx->input_end) {
-+					goto fail;
-+				}
-+				c1 = duk__inp_get_cp(re_ctx, &p);
-+				c2 = duk__inp_get_cp(re_ctx, &sp);
-+				if (c1 != c2) {
-+					goto fail;
-+				}
-+			}
-+			break;
-+		}
-+		default: {
-+			DUK_D(DUK_DPRINT("internal error, regexp opcode error: %ld", (long) op));
-+			goto internal_error;
-+		}
-+		}
-+	}
-+
-+ match:
-+	re_ctx->recursion_depth--;
-+	return sp;
-+
-+ fail:
-+	re_ctx->recursion_depth--;
-+	return NULL;
-+
-+ internal_error:
-+	DUK_ERROR(re_ctx->thr, DUK_ERR_INTERNAL_ERROR, DUK_STR_REGEXP_INTERNAL_ERROR);
-+	return NULL;  /* never here */
-+}
-+
-+/*
-+ *  Exposed matcher function which provides the semantics of RegExp.prototype.exec().
-+ *
-+ *  RegExp.prototype.test() has the same semantics as exec() but does not return the
-+ *  result object (which contains the matching string and capture groups).  Currently
-+ *  there is no separate test() helper, so a temporary result object is created and
-+ *  discarded if test() is needed.  This is intentional, to save code space.
-+ *
-+ *  Input stack:  [ ... re_obj input ]
-+ *  Output stack: [ ... result ]
-+ */
-+
-+DUK_LOCAL void duk__regexp_match_helper(duk_hthread *thr, duk_small_int_t force_global) {
-+	duk_context *ctx = (duk_context *) thr;
-+	duk_re_matcher_ctx re_ctx;
-+	duk_hobject *h_regexp;
-+	duk_hstring *h_bytecode;
-+	duk_hstring *h_input;
-+	const duk_uint8_t *pc;
-+	const duk_uint8_t *sp;
-+	duk_small_int_t match = 0;
-+	duk_small_int_t global;
-+	duk_uint_fast32_t i;
-+	double d;
-+	duk_uint32_t char_offset;
-+
-+	DUK_ASSERT(thr != NULL);
-+	DUK_ASSERT(ctx != NULL);
-+
-+	DUK_DD(DUK_DDPRINT("regexp match: regexp=%!T, input=%!T",
-+	                   (duk_tval *) duk_get_tval(ctx, -2),
-+	                   (duk_tval *) duk_get_tval(ctx, -1)));
-+
-+	/*
-+	 *  Regexp instance check, bytecode check, input coercion.
-+	 *
-+	 *  See E5 Section 15.10.6.
-+	 */
-+
-+	/* TypeError if wrong; class check, see E5 Section 15.10.6 */
-+	h_regexp = duk_require_hobject_with_class(ctx, -2, DUK_HOBJECT_CLASS_REGEXP);
-+	DUK_ASSERT(h_regexp != NULL);
-+	DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_regexp) == DUK_HOBJECT_CLASS_REGEXP);
-+	DUK_UNREF(h_regexp);
-+
-+	duk_to_string(ctx, -1);
-+	h_input = duk_get_hstring(ctx, -1);
-+	DUK_ASSERT(h_input != NULL);
-+
-+	duk_get_prop_stridx(ctx, -2, DUK_STRIDX_INT_BYTECODE);  /* [ ... re_obj input ] -> [ ... re_obj input bc ] */
-+	h_bytecode = duk_require_hstring(ctx, -1);  /* no regexp instance should exist without a non-configurable bytecode property */
-+	DUK_ASSERT(h_bytecode != NULL);
-+
-+	/*
-+	 *  Basic context initialization.
-+	 *
-+	 *  Some init values are read from the bytecode header
-+	 *  whose format is (UTF-8 codepoints):
-+	 *
-+	 *    uint   flags
-+	 *    uint   nsaved (even, 2n+2 where n = num captures)
-+	 */
-+
-+	/* [ ... re_obj input bc ] */
-+
-+	DUK_MEMZERO(&re_ctx, sizeof(re_ctx));
-+
-+	re_ctx.thr = thr;
-+	re_ctx.input = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_input);
-+	re_ctx.input_end = re_ctx.input + DUK_HSTRING_GET_BYTELEN(h_input);
-+	re_ctx.bytecode = (duk_uint8_t *) DUK_HSTRING_GET_DATA(h_bytecode);
-+	re_ctx.bytecode_end = re_ctx.bytecode + DUK_HSTRING_GET_BYTELEN(h_bytecode);
-+	re_ctx.saved = NULL;
-+	re_ctx.recursion_limit = DUK_RE_EXECUTE_RECURSION_LIMIT;
-+	re_ctx.steps_limit = DUK_RE_EXECUTE_STEPS_LIMIT;
-+
-+	/* read header */
-+	pc = re_ctx.bytecode;
-+	re_ctx.re_flags = duk__bc_get_u32(&re_ctx, &pc);
-+	re_ctx.nsaved = duk__bc_get_u32(&re_ctx, &pc);
-+	re_ctx.bytecode = pc;
-+
-+	DUK_ASSERT(DUK_RE_FLAG_GLOBAL < 0x10000UL);  /* must fit into duk_small_int_t */
-+	global = (duk_small_int_t) (force_global | (re_ctx.re_flags & DUK_RE_FLAG_GLOBAL));
-+
-+	DUK_ASSERT(re_ctx.nsaved >= 2);
-+	DUK_ASSERT((re_ctx.nsaved % 2) == 0);
-+
-+	duk_push_fixed_buffer(ctx, sizeof(duk_uint8_t *) * re_ctx.nsaved);
-+	re_ctx.saved = (const duk_uint8_t **) duk_get_buffer(ctx, -1, NULL);
-+	DUK_ASSERT(re_ctx.saved != NULL);
-+
-+	/* [ ... re_obj input bc saved_buf ] */
-+
-+	/* buffer is automatically zeroed */
-+#ifdef DUK_USE_EXPLICIT_NULL_INIT
-+	for (i = 0; i < re_ctx.nsaved; i++) {
-+		re_ctx.saved[i] = (duk_uint8_t *) NULL;
-+	}
-+#endif
-+
-+	DUK_DDD(DUK_DDDPRINT("regexp ctx initialized, flags=0x%08lx, nsaved=%ld, recursion_limit=%ld, steps_limit=%ld",
-+	                     (unsigned long) re_ctx.re_flags, (long) re_ctx.nsaved, (long) re_ctx.recursion_limit,
-+	                     (long) re_ctx.steps_limit));
-+
-+	/*
-+	 *  Get starting character offset for match, and initialize 'sp' based on it.
-+	 *
-+	 *  Note: lastIndex is non-configurable so it must be present (we check the
-+	 *  internal class of the object above, so we know it is).  User code can set
-+	 *  its value to an arbitrary (garbage) value though; E5 requires that lastIndex
-+	 *  be coerced to a number before using.  The code below works even if the
-+	 *  property is missing: the value will then be coerced to zero.
-+	 *
-+	 *  Note: lastIndex may be outside Uint32 range even after ToInteger() coercion.
-+	 *  For instance, ToInteger(+Infinity) = +Infinity.  We track the match offset
-+	 *  as an integer, but pre-check it to be inside the 32-bit range before the loop.
-+	 *  If not, the check in E5 Section 15.10.6.2, step 9.a applies.
-+	 */
-+
-+	/* XXX: lastIndex handling produces a lot of asm */
-+
-+	/* [ ... re_obj input bc saved_buf ] */
-+
-+	duk_get_prop_stridx(ctx, -4, DUK_STRIDX_LAST_INDEX);  /* -> [ ... re_obj input bc saved_buf lastIndex ] */
-+	(void) duk_to_int(ctx, -1);  /* ToInteger(lastIndex) */
-+	d = duk_get_number(ctx, -1);  /* integer, but may be +/- Infinite, +/- zero (not NaN, though) */
-+	duk_pop(ctx);
-+
-+	if (global) {
-+		if (d < 0.0 || d > (double) DUK_HSTRING_GET_CHARLEN(h_input)) {
-+			/* match fail */
-+			char_offset = 0;   /* not really necessary */
-+			DUK_ASSERT(match == 0);
-+			goto match_over;
-+		}
-+		char_offset = (duk_uint32_t) d;
-+	} else {
-+		/* lastIndex must be ignored for non-global regexps, but get the
-+		 * value for (theoretical) side effects.  No side effects can
-+		 * really occur, because lastIndex is a normal property and is
-+		 * always non-configurable for RegExp instances.
-+		 */
-+		char_offset = (duk_uint32_t) 0;
-+	}
-+
-+	sp = re_ctx.input + duk_heap_strcache_offset_char2byte(thr, h_input, char_offset);
-+
-+	/*
-+	 *  Match loop.
-+	 *
-+	 *  Try matching at different offsets until match found or input exhausted.
-+	 */
-+
-+	/* [ ... re_obj input bc saved_buf ] */
-+
-+	DUK_ASSERT(match == 0);
-+
-+	for (;;) {
-+		/* char offset in [0, h_input->clen] (both ends inclusive), checked before entry */
-+		DUK_ASSERT_DISABLE(char_offset >= 0);
-+		DUK_ASSERT(char_offset <= DUK_HSTRING_GET_CHARLEN(h_input));
-+
-+		/* Note: ctx.steps is intentionally not reset, it applies to the entire unanchored match */
-+		DUK_ASSERT(re_ctx.recursion_depth == 0);
-+
-+		DUK_DDD(DUK_DDDPRINT("attempt match at char offset %ld; %p [%p,%p]",
-+		                     (long) char_offset, (void *) sp, (void *) re_ctx.input,
-+		                     (void *) re_ctx.input_end));
-+
-+		/*
-+		 *  Note:
-+		 *
-+		 *    - duk__match_regexp() is required not to longjmp() in ordinary "non-match"
-+		 *      conditions; a longjmp() will terminate the entire matching process.
-+		 *
-+		 *    - Clearing saved[] is not necessary because backtracking does it
-+		 *
-+		 *    - Backtracking also rewinds ctx.recursion back to zero, unless an
-+		 *      internal/limit error occurs (which causes a longjmp())
-+		 *
-+		 *    - If we supported anchored matches, we would break out here
-+		 *      unconditionally; however, Ecmascript regexps don't have anchored
-+		 *      matches.  It might make sense to implement a fast bail-out if
-+		 *      the regexp begins with '^' and sp is not 0: currently we'll just
-+		 *      run through the entire input string, trivially failing the match
-+		 *      at every non-zero offset.
-+		 */
-+
-+		if (duk__match_regexp(&re_ctx, re_ctx.bytecode, sp) != NULL) {
-+			DUK_DDD(DUK_DDDPRINT("match at offset %ld", (long) char_offset));
-+			match = 1;
-+			break;
-+		}
-+
-+		/* advance by one character (code point) and one char_offset */
-+		char_offset++;
-+		if (char_offset > DUK_HSTRING_GET_CHARLEN(h_input)) {
-+			/*
-+			 *  Note:
-+			 *
-+			 *    - Intentionally attempt (empty) match at char_offset == k_input->clen
-+			 *
-+			 *    - Negative char_offsets have been eliminated and char_offset is duk_uint32_t
-+			 *      -> no need or use for a negative check
-+			 */
-+
-+			DUK_DDD(DUK_DDDPRINT("no match after trying all sp offsets"));
-+			break;
-+		}
-+
-+		/* avoid calling at end of input, will DUK_ERROR (above check suffices to avoid this) */
-+		(void) duk__utf8_advance(thr, &sp, re_ctx.input, re_ctx.input_end, (duk_uint_fast32_t) 1);
-+	}
-+
-+ match_over:
-+
-+	/*
-+	 *  Matching complete, create result array or return a 'null'.  Update lastIndex
-+	 *  if necessary.  See E5 Section 15.10.6.2.
-+	 *
-+	 *  Because lastIndex is a character (not byte) offset, we need the character
-+	 *  length of the match which we conveniently get as a side effect of interning
-+	 *  the matching substring (0th index of result array).
-+	 *
-+	 *  saved[0]         start pointer (~ byte offset) of current match
-+	 *  saved[1]         end pointer (~ byte offset) of current match (exclusive)
-+	 *  char_offset      start character offset of current match (-> .index of result)
-+	 *  char_end_offset  end character offset (computed below)
-+	 */
-+
-+	/* [ ... re_obj input bc saved_buf ] */
-+
-+	if (match) {
-+#ifdef DUK_USE_ASSERTIONS
-+		duk_hobject *h_res;
-+#endif
-+		duk_uint32_t char_end_offset = 0;
-+
-+		DUK_DDD(DUK_DDDPRINT("regexp matches at char_offset %ld", (long) char_offset));
-+
-+		DUK_ASSERT(re_ctx.nsaved >= 2);        /* must have start and end */
-+		DUK_ASSERT((re_ctx.nsaved % 2) == 0);  /* and even number */
-+
-+		/* XXX: Array size is known before and (2 * re_ctx.nsaved) but not taken
-+		 * advantage of now.  The array is not compacted either, as regexp match
-+		 * objects are usually short lived.
-+		 */
-+
-+		duk_push_array(ctx);
-+
-+#ifdef DUK_USE_ASSERTIONS
-+		h_res = duk_require_hobject(ctx, -1);
-+		DUK_ASSERT(DUK_HOBJECT_HAS_EXTENSIBLE(h_res));
-+		DUK_ASSERT(DUK_HOBJECT_HAS_EXOTIC_ARRAY(h_res));
-+		DUK_ASSERT(DUK_HOBJECT_GET_CLASS_NUMBER(h_res) == DUK_HOBJECT_CLASS_ARRAY);
-+#endif
-+
-+		/* [ ... re_obj input bc saved_buf res_obj ] */
-+
-+		duk_push_u32(ctx, char_offset);
-+		duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INDEX);
-+
-+		duk_dup(ctx, -4);
-+		duk_xdef_prop_stridx_wec(ctx, -2, DUK_STRIDX_INPUT);
-+
-+		for (i = 0; i < re_ctx.nsaved; i += 2) {
-+			/* Captures which are undefined have NULL pointers and are returned
-+			 * as 'undefined'.  The same is done when saved[] pointers are insane
-+			 * (this should, of course, never happen in practice).
-+			 */
-+			if (re_ctx.saved[i] && re_ctx.saved[i+1] && re_ctx.saved[i+1] >= re_ctx.saved[i]) {
-+				duk_hstring *h_saved;
-+
-+				duk_push_lstring(ctx,
-+				                 (char *) re_ctx.saved[i],
-+				                 (duk_size_t) (re_ctx.saved[i+1] - re_ctx.saved[i]));
-+				h_saved = duk_get_hstring(ctx, -1);
-+				DUK_ASSERT(h_saved != NULL);
-+
-+				if (i == 0) {
-+					/* Assumes that saved[0] and saved[1] are always
-+					 * set by regexp bytecode (if not, char_end_offset
-+					 * will be zero).  Also assumes clen reflects the
-+					 * correct char length.
-+					 */
-+					char_end_offset = char_offset + DUK_HSTRING_GET_CHARLEN(h_saved);
-+				}
-+			} else {
-+				duk_push_undefined(ctx);
-+			}
-+
-+			/* [ ... re_obj input bc saved_buf res_obj val ] */
-+			duk_put_prop_index(ctx, -2, i / 2);
-+		}
-+
-+		/* [ ... re_obj input bc saved_buf res_obj ] */
-+
-+		/* NB: 'length' property is automatically updated by the array setup loop */
-+
-+		if (global) {
-+			/* global regexp: lastIndex updated on match */
-+			duk_push_u32(ctx, char_end_offset);
-+			duk_put_prop_stridx(ctx, -6, DUK_STRIDX_LAST_INDEX);
-+		} else {
-+			/* non-global regexp: lastIndex never updated on match */
-+			;
-+		}
-+	} else {
-+		/*
-+		 *  No match, E5 Section 15.10.6.2, step 9.a.i - 9.a.ii apply, regardless
-+		 *  of 'global' flag of the RegExp.  In particular, if lastIndex is invalid
-+		 *  initially, it is reset to zero.
-+		 */
-+
-+		DUK_DDD(DUK_DDDPRINT("regexp does not match"));
-+
-+		duk_push_null(ctx);
-+
-+		/* [ ... re_obj input bc saved_buf res_obj ] */
-+
-+		duk_push_int(ctx, 0);
-+		duk_put_prop_stridx(ctx, -6, DUK_STRIDX_LAST_INDEX);
-+	}
-+
-+	/* [ ... re_obj input bc saved_buf res_obj ] */
-+
-+	duk_insert(ctx, -5);
-+
-+	/* [ ... res_obj re_obj input bc saved_buf ] */
-+
-+	duk_pop_n(ctx, 4);
-+
-+	/* [ ... res_obj ] */
-+
-+	/* XXX: these last tricks are unnecessary if the function is made
-+	 * a genuine native function.
-+	 */
-+}
-+
-+DUK_INTERNAL void duk_regexp_match(duk_hthread *thr) {
-+	duk__regexp_match_helper(thr, 0 /*force_global*/);
-+}
-+
-+/* This variant is needed by String.prototype.split(); it needs to perform
-+ * global-style matching on a cloned RegExp which is potentially non-global.
-+ */
-+DUK_INTERNAL void duk_regexp_match_force_global(duk_hthread *thr) {
-+	duk__regexp_match_helper(thr, 1 /*force_global*/);
-+}
-+
-+#else  /* DUK_USE_REGEXP_SUPPORT */
-+
-+/* regexp support disabled */
-+
-+#endif  /* DUK_USE_REGEXP_SUPPORT */
-+#line 1 "duk_replacements.c"
-+/*
-+ *  Replacements for missing platform functions.
-+ *
-+ *  Unlike the originals, fpclassify() and signbit() replacements don't
-+ *  work on any floating point types, only doubles.  The C typing here
-+ *  mimics the standard prototypes.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#ifdef DUK_USE_COMPUTED_NAN
-+DUK_INTERNAL double duk_computed_nan;
-+#endif
-+
-+#ifdef DUK_USE_COMPUTED_INFINITY
-+DUK_INTERNAL double duk_computed_infinity;
-+#endif
-+
-+#ifdef DUK_USE_REPL_FPCLASSIFY
-+DUK_INTERNAL int duk_repl_fpclassify(double x) {
-+	duk_double_union u;
-+	duk_uint_fast16_t expt;
-+	duk_small_int_t mzero;
-+
-+	u.d = x;
-+	expt = (duk_uint_fast16_t) (u.us[DUK_DBL_IDX_US0] & 0x7ff0UL);
-+	if (expt > 0x0000UL && expt < 0x7ff0UL) {
-+		/* expt values [0x001,0x7fe] = normal */
-+		return DUK_FP_NORMAL;
-+	}
-+
-+	mzero = (u.ui[DUK_DBL_IDX_UI1] == 0 && (u.ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) == 0);
-+	if (expt == 0x0000UL) {
-+		/* expt 0x000 is zero/subnormal */
-+		if (mzero) {
-+			return DUK_FP_ZERO;
-+		} else {
-+			return DUK_FP_SUBNORMAL;
-+		}
-+	} else {
-+		/* expt 0xfff is infinite/nan */
-+		if (mzero) {
-+			return DUK_FP_INFINITE;
-+		} else {
-+			return DUK_FP_NAN;
-+		}
-+	}
-+}
-+#endif
-+
-+#ifdef DUK_USE_REPL_SIGNBIT
-+DUK_INTERNAL int duk_repl_signbit(double x) {
-+	duk_double_union u;
-+	u.d = x;
-+	return (int) (u.uc[DUK_DBL_IDX_UC0] & 0x80UL);
-+}
-+#endif
-+
-+#ifdef DUK_USE_REPL_ISFINITE
-+DUK_INTERNAL int duk_repl_isfinite(double x) {
-+	int c = DUK_FPCLASSIFY(x);
-+	if (c == DUK_FP_NAN || c == DUK_FP_INFINITE) {
-+		return 0;
-+	} else {
-+		return 1;
-+	}
-+}
-+#endif
-+
-+#ifdef DUK_USE_REPL_ISNAN
-+DUK_INTERNAL int duk_repl_isnan(double x) {
-+	int c = DUK_FPCLASSIFY(x);
-+	return (c == DUK_FP_NAN);
-+}
-+#endif
-+
-+#ifdef DUK_USE_REPL_ISINF
-+DUK_INTERNAL int duk_repl_isinf(double x) {
-+	int c = DUK_FPCLASSIFY(x);
-+	return (c == DUK_FP_INFINITE);
-+}
-+#endif
-+#line 1 "duk_selftest.c"
-+/*
-+ *  Self tests to ensure execution environment is sane.  Intended to catch
-+ *  compiler/platform problems which cannot be detected at compile time.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#if defined(DUK_USE_SELF_TESTS)
-+
-+/*
-+ *  Unions and structs for self tests
-+ */
-+
-+typedef union {
-+	double d;
-+	duk_uint8_t c[8];
-+} duk__test_double_union;
-+
-+#define DUK__DBLUNION_CMP_TRUE(a,b)  do { \
-+		if (DUK_MEMCMP((void *) (a), (void *) (b), sizeof(duk__test_double_union)) != 0) { \
-+			DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double union compares false (expected true)"); \
-+		} \
-+	} while (0)
-+
-+#define DUK__DBLUNION_CMP_FALSE(a,b)  do { \
-+		if (DUK_MEMCMP((void *) (a), (void *) (b), sizeof(duk__test_double_union)) == 0) { \
-+			DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double union compares true (expected false)"); \
-+		} \
-+	} while (0)
-+
-+typedef union {
-+	duk_uint32_t i;
-+	duk_uint8_t c[8];
-+} duk__test_u32_union;
-+
-+/*
-+ *  Various sanity checks for typing
-+ */
-+
-+DUK_LOCAL void duk__selftest_types(void) {
-+	if (!(sizeof(duk_int8_t) == 1 &&
-+	      sizeof(duk_uint8_t) == 1 &&
-+	      sizeof(duk_int16_t) == 2 &&
-+	      sizeof(duk_uint16_t) == 2 &&
-+	      sizeof(duk_int32_t) == 4 &&
-+	      sizeof(duk_uint32_t) == 4)) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_(u)int{8,16,32}_t size");
-+	}
-+#if defined(DUK_USE_64BIT_OPS)
-+	if (!(sizeof(duk_int64_t) == 8 &&
-+	      sizeof(duk_uint64_t) == 8)) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_(u)int64_t size");
-+	}
-+#endif
-+
-+	if (!(sizeof(duk_size_t) >= sizeof(duk_uint_t))) {
-+		/* Some internal code now assumes that all duk_uint_t values
-+		 * can be expressed with a duk_size_t.
-+		 */
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_size_t is smaller than duk_uint_t");
-+	}
-+	if (!(sizeof(duk_int_t) >= 4)) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_int_t is not 32 bits");
-+	}
-+}
-+
-+/*
-+ *  Packed tval sanity
-+ */
-+
-+DUK_LOCAL void duk__selftest_packed_tval(void) {
-+#if defined(DUK_USE_PACKED_TVAL)
-+	if (sizeof(void *) > 4) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: packed duk_tval in use but sizeof(void *) > 4");
-+	}
-+#endif
-+}
-+
-+/*
-+ *  Two's complement arithmetic.
-+ */
-+
-+DUK_LOCAL void duk__selftest_twos_complement(void) {
-+	volatile int test;
-+	test = -1;
-+	if (((duk_uint8_t *) &test)[0] != (duk_uint8_t) 0xff) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: two's complement arithmetic");
-+	}
-+}
-+
-+/*
-+ *  Byte order.  Important to self check, because on some exotic platforms
-+ *  there is no actual detection but rather assumption based on platform
-+ *  defines.
-+ */
-+
-+DUK_LOCAL void duk__selftest_byte_order(void) {
-+	duk__test_u32_union u1;
-+	duk__test_double_union u2;
-+
-+	/*
-+	 *  >>> struct.pack('>d', 102030405060).encode('hex')
-+	 *  '4237c17c6dc40000'
-+	 */
-+#if defined(DUK_USE_INTEGER_LE)
-+	u1.c[0] = 0xef; u1.c[1] = 0xbe; u1.c[2] = 0xad; u1.c[3] = 0xde;
-+#elif defined(DUK_USE_INTEGER_ME)
-+#error integer mixed endian not supported now
-+#elif defined(DUK_USE_INTEGER_BE)
-+	u1.c[0] = 0xde; u1.c[1] = 0xad; u1.c[2] = 0xbe; u1.c[3] = 0xef;
-+#else
-+#error unknown integer endianness
-+#endif
-+
-+#if defined(DUK_USE_DOUBLE_LE)
-+	u2.c[0] = 0x00; u2.c[1] = 0x00; u2.c[2] = 0xc4; u2.c[3] = 0x6d;
-+	u2.c[4] = 0x7c; u2.c[5] = 0xc1; u2.c[6] = 0x37; u2.c[7] = 0x42;
-+#elif defined(DUK_USE_DOUBLE_ME)
-+	u2.c[0] = 0x7c; u2.c[1] = 0xc1; u2.c[2] = 0x37; u2.c[3] = 0x42;
-+	u2.c[4] = 0x00; u2.c[5] = 0x00; u2.c[6] = 0xc4; u2.c[7] = 0x6d;
-+#elif defined(DUK_USE_DOUBLE_BE)
-+	u2.c[0] = 0x42; u2.c[1] = 0x37; u2.c[2] = 0xc1; u2.c[3] = 0x7c;
-+	u2.c[4] = 0x6d; u2.c[5] = 0xc4; u2.c[6] = 0x00; u2.c[7] = 0x00;
-+#else
-+#error unknown double endianness
-+#endif
-+
-+	if (u1.i != (duk_uint32_t) 0xdeadbeefUL) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: duk_uint32_t byte order");
-+	}
-+
-+	if (u2.d != (double) 102030405060.0) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double byte order");
-+	}
-+}
-+
-+/*
-+ *  DUK_BSWAP macros
-+ */
-+
-+DUK_LOCAL void duk__selftest_bswap_macros(void) {
-+	duk_uint32_t x32;
-+	duk_uint16_t x16;
-+	duk_double_union du;
-+	duk_double_t du_diff;
-+
-+	x16 = 0xbeefUL;
-+	x16 = DUK_BSWAP16(x16);
-+	if (x16 != (duk_uint16_t) 0xefbeUL) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_BSWAP16");
-+	}
-+
-+	x32 = 0xdeadbeefUL;
-+	x32 = DUK_BSWAP32(x32);
-+	if (x32 != (duk_uint32_t) 0xefbeaddeUL) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_BSWAP32");
-+	}
-+
-+	/* >>> struct.unpack('>d', '4000112233445566'.decode('hex'))
-+	 * (2.008366013071895,)
-+	 */
-+
-+	du.uc[0] = 0x40; du.uc[1] = 0x00; du.uc[2] = 0x11; du.uc[3] = 0x22;
-+	du.uc[4] = 0x33; du.uc[5] = 0x44; du.uc[6] = 0x55; du.uc[7] = 0x66;
-+	DUK_DBLUNION_BSWAP(&du);
-+	du_diff = du.d - 2.008366013071895;
-+#if 0
-+	DUK_FPRINTF(DUK_STDERR, "du_diff: %lg\n", (double) du_diff);
-+#endif
-+	if (du_diff > 1e-15) {
-+		/* Allow very small lenience because some compilers won't parse
-+		 * exact IEEE double constants (happened in matrix testing with
-+		 * Linux gcc-4.8 -m32 at least).
-+		 */
-+#if 0
-+		DUK_FPRINTF(DUK_STDERR, "Result of DUK_DBLUNION_BSWAP: %02x %02x %02x %02x %02x %02x %02x %02x\n",
-+		            (unsigned int) du.uc[0], (unsigned int) du.uc[1],
-+		            (unsigned int) du.uc[2], (unsigned int) du.uc[3],
-+		            (unsigned int) du.uc[4], (unsigned int) du.uc[5],
-+		            (unsigned int) du.uc[6], (unsigned int) du.uc[7]);
-+#endif
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: DUK_DBLUNION_BSWAP");
-+	}
-+}
-+
-+/*
-+ *  Basic double / byte union memory layout.
-+ */
-+
-+DUK_LOCAL void duk__selftest_double_union_size(void) {
-+	if (sizeof(duk__test_double_union) != 8) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: invalid union size");
-+	}
-+}
-+
-+/*
-+ *  Union aliasing, see misc/clang_aliasing.c.
-+ */
-+
-+DUK_LOCAL void duk__selftest_double_aliasing(void) {
-+	duk__test_double_union a, b;
-+
-+	/* This testcase fails when Emscripten-generated code runs on Firefox.
-+	 * It's not an issue because the failure should only affect packed
-+	 * duk_tval representation, which is not used with Emscripten.
-+	 */
-+#if defined(DUK_USE_NO_DOUBLE_ALIASING_SELFTEST)
-+#if defined(DUK_USE_PACKED_TVAL)
-+#error inconsistent defines: skipping double aliasing selftest when using packed duk_tval
-+#endif
-+	return;
-+#endif
-+
-+	/* Test signaling NaN and alias assignment in all
-+	 * endianness combinations.
-+	 */
-+
-+	/* little endian */
-+	a.c[0] = 0x11; a.c[1] = 0x22; a.c[2] = 0x33; a.c[3] = 0x44;
-+	a.c[4] = 0x00; a.c[5] = 0x00; a.c[6] = 0xf1; a.c[7] = 0xff;
-+	b = a;
-+	DUK__DBLUNION_CMP_TRUE(&a, &b);
-+
-+	/* big endian */
-+	a.c[0] = 0xff; a.c[1] = 0xf1; a.c[2] = 0x00; a.c[3] = 0x00;
-+	a.c[4] = 0x44; a.c[5] = 0x33; a.c[6] = 0x22; a.c[7] = 0x11;
-+	b = a;
-+	DUK__DBLUNION_CMP_TRUE(&a, &b);
-+
-+	/* mixed endian */
-+	a.c[0] = 0x00; a.c[1] = 0x00; a.c[2] = 0xf1; a.c[3] = 0xff;
-+	a.c[4] = 0x11; a.c[5] = 0x22; a.c[6] = 0x33; a.c[7] = 0x44;
-+	b = a;
-+	DUK__DBLUNION_CMP_TRUE(&a, &b);
-+}
-+
-+/*
-+ *  Zero sign, see misc/tcc_zerosign2.c.
-+ */
-+
-+DUK_LOCAL void duk__selftest_double_zero_sign(void) {
-+	volatile duk__test_double_union a, b;
-+
-+	a.d = 0.0;
-+	b.d = -a.d;
-+	DUK__DBLUNION_CMP_FALSE(&a, &b);
-+}
-+
-+/*
-+ *  Struct size/alignment if platform requires it
-+ *
-+ *  There are some compiler specific struct padding pragmas etc in use, this
-+ *  selftest ensures they're correctly detected and used.
-+ */
-+
-+DUK_LOCAL void duk__selftest_struct_align(void) {
-+#if defined(DUK_USE_ALIGN_4)
-+	if ((sizeof(duk_hbuffer_fixed) % 4) != 0) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: sizeof(duk_hbuffer_fixed) not aligned to 4");
-+	}
-+#elif defined(DUK_USE_ALIGN_8)
-+	if ((sizeof(duk_hbuffer_fixed) % 8) != 0) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: sizeof(duk_hbuffer_fixed) not aligned to 8");
-+	}
-+#else
-+	/* no check */
-+#endif
-+}
-+
-+/*
-+ *  64-bit arithmetic
-+ *
-+ *  There are some platforms/compilers where 64-bit types are available
-+ *  but don't work correctly.  Test for known cases.
-+ */
-+
-+DUK_LOCAL void duk__selftest_64bit_arithmetic(void) {
-+#if defined(DUK_USE_64BIT_OPS)
-+	volatile duk_int64_t i;
-+	volatile duk_double_t d;
-+
-+	/* Catch a double-to-int64 cast issue encountered in practice. */
-+	d = 2147483648.0;
-+	i = (duk_int64_t) d;
-+	if (i != 0x80000000LL) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: casting 2147483648.0 to duk_int64_t failed");
-+	}
-+#else
-+	/* nop */
-+#endif
-+}
-+
-+/*
-+ *  Casting
-+ */
-+
-+DUK_LOCAL void duk__selftest_cast_double_to_uint(void) {
-+	/*
-+	 *  https://github.com/svaarala/duktape/issues/127#issuecomment-77863473
-+	 */
-+
-+	duk_double_t d1, d2;
-+	duk_small_uint_t u;
-+
-+	duk_double_t d1v, d2v;
-+	duk_small_uint_t uv;
-+
-+	d1 = 1.0;
-+	u = (duk_small_uint_t) d1;
-+	d2 = (duk_double_t) u;
-+
-+	if (!(d1 == 1.0 && u == 1 && d2 == 1.0 && d1 == d2)) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to uint cast failed");
-+	}
-+
-+	/* Same test with volatiles */
-+
-+	d1v = 1.0;
-+	uv = (duk_small_uint_t) d1v;
-+	d2v = (duk_double_t) uv;
-+
-+	if (!(d1v == 1.0 && uv == 1 && d2v == 1.0 && d1v == d2v)) {
-+		DUK_PANIC(DUK_ERR_INTERNAL_ERROR, "self test failed: double to uint cast failed");
-+	}
-+}
-+
-+/*
-+ *  Self test main
-+ */
-+
-+DUK_INTERNAL void duk_selftest_run_tests(void) {
-+	duk__selftest_types();
-+	duk__selftest_packed_tval();
-+	duk__selftest_twos_complement();
-+	duk__selftest_byte_order();
-+	duk__selftest_bswap_macros();
-+	duk__selftest_double_union_size();
-+	duk__selftest_double_aliasing();
-+	duk__selftest_double_zero_sign();
-+	duk__selftest_struct_align();
-+	duk__selftest_64bit_arithmetic();
-+	duk__selftest_cast_double_to_uint();
-+}
-+
-+#undef DUK__DBLUNION_CMP_TRUE
-+#undef DUK__DBLUNION_CMP_FALSE
-+
-+#endif  /* DUK_USE_SELF_TESTS */
-+/* include removed: duk_internal.h */
-+#line 2 "duk_tval.c"
-+
-+#if defined(DUK_USE_FASTINT)
-+
-+/*
-+ *  Manually optimized double-to-fastint downgrade check.
-+ *
-+ *  This check has a large impact on performance, especially for fastint
-+ *  slow paths, so must be changed carefully.  The code should probably be
-+ *  optimized for the case where the result does not fit into a fastint,
-+ *  to minimize the penalty for "slow path code" dealing with fractions etc.
-+ *
-+ *  At least on one tested soft float ARM platform double-to-int64 coercion
-+ *  is very slow (and sometimes produces incorrect results, see self tests).
-+ *  This algorithm combines a fastint compatibility check and extracting the
-+ *  integer value from an IEEE double for setting the tagged fastint.  For
-+ *  other platforms a more naive approach might be better.
-+ *
-+ *  See doc/fastint.rst for details.
-+ */
-+
-+DUK_INTERNAL DUK_ALWAYS_INLINE void duk_tval_set_number_chkfast(duk_tval *tv, duk_double_t x) {
-+	duk_double_union du;
-+	duk_int64_t i;
-+	duk_small_int_t expt;
-+	duk_small_int_t shift;
-+
-+	/* XXX: optimize for packed duk_tval directly? */
-+
-+	du.d = x;
-+	i = (duk_int64_t) DUK_DBLUNION_GET_INT64(&du);
-+	expt = (duk_small_int_t) ((i >> 52) & 0x07ff);
-+	shift = expt - 1023;
-+
-+	if (shift >= 0 && shift <= 46) {  /* exponents 1023 to 1069 */
-+		duk_int64_t t;
-+
-+		if (((0x000fffffffffffffLL >> shift) & i) == 0) {
-+			t = i | 0x0010000000000000LL;  /* implicit leading one */
-+			t = t & 0x001fffffffffffffLL;
-+			t = t >> (52 - shift);
-+			if (i < 0) {
-+				t = -t;
-+			}
-+			DUK_TVAL_SET_FASTINT(tv, t);
-+			return;
-+		}
-+	} else if (shift == -1023) {  /* exponent 0 */
-+		if (i >= 0 && (i & 0x000fffffffffffffLL) == 0) {
-+			/* Note: reject negative zero. */
-+			DUK_TVAL_SET_FASTINT(tv, (duk_int64_t) 0);
-+			return;
-+		}
-+	} else if (shift == 47) {  /* exponent 1070 */
-+		if (i < 0 && (i & 0x000fffffffffffffLL) == 0) {
-+			DUK_TVAL_SET_FASTINT(tv, (duk_int64_t) DUK_FASTINT_MIN);
-+			return;
-+		}
-+	}
-+
-+	DUK_TVAL_SET_DOUBLE(tv, x);
-+	return;
-+}
-+
-+/*
-+ *  Manually optimized number-to-double conversion
-+ */
-+
-+#if defined(DUK_USE_FASTINT) && defined(DUK_USE_PACKED_TVAL)
-+DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_packed(duk_tval *tv) {
-+	duk_double_union du;
-+	duk_uint64_t t;
-+
-+	t = (duk_uint64_t) DUK_DBLUNION_GET_UINT64(tv);
-+	if ((t >> 48) != DUK_TAG_FASTINT) {
-+		return tv->d;
-+	} else if (t & 0x0000800000000000ULL) {
-+		t = (duk_uint64_t) (-((duk_int64_t) t));  /* avoid unary minus on unsigned */
-+		t = t & 0x0000ffffffffffffULL;  /* negative */
-+		t |= 0xc330000000000000ULL;
-+		DUK_DBLUNION_SET_UINT64(&du, t);
-+		return du.d + 4503599627370496.0;  /* 1 << 52 */
-+	} else if (t != 0) {
-+		t &= 0x0000ffffffffffffULL;  /* positive */
-+		t |= 0x4330000000000000ULL;
-+		DUK_DBLUNION_SET_UINT64(&du, t);
-+		return du.d - 4503599627370496.0;  /* 1 << 52 */
-+	} else {
-+		return 0.0;  /* zero */
-+	}
-+}
-+#endif  /* DUK_USE_FASTINT && DUK_USE_PACKED_TVAL */
-+
-+#if 0  /* unused */
-+#if defined(DUK_USE_FASTINT) && !defined(DUK_USE_PACKED_TVAL)
-+DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked(duk_tval *tv) {
-+	duk_double_union du;
-+	duk_uint64_t t;
-+
-+	DUK_ASSERT(tv->t == DUK__TAG_NUMBER || tv->t == DUK_TAG_FASTINT);
-+
-+	if (tv->t == DUK_TAG_FASTINT) {
-+		if (tv->v.fi >= 0) {
-+			t = 0x4330000000000000ULL | (duk_uint64_t) tv->v.fi;
-+			DUK_DBLUNION_SET_UINT64(&du, t);
-+			return du.d - 4503599627370496.0;  /* 1 << 52 */
-+		} else {
-+			t = 0xc330000000000000ULL | (duk_uint64_t) (-tv->v.fi);
-+			DUK_DBLUNION_SET_UINT64(&du, t);
-+			return du.d + 4503599627370496.0;  /* 1 << 52 */
-+		}
-+	} else {
-+		return tv->v.d;
-+	}
-+}
-+#endif  /* DUK_USE_FASTINT && DUK_USE_PACKED_TVAL */
-+#endif  /* 0 */
-+
-+#if defined(DUK_USE_FASTINT) && !defined(DUK_USE_PACKED_TVAL)
-+DUK_INTERNAL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked_fastint(duk_tval *tv) {
-+	duk_double_union du;
-+	duk_uint64_t t;
-+
-+	DUK_ASSERT(tv->t == DUK_TAG_FASTINT);
-+
-+	if (tv->v.fi >= 0) {
-+		t = 0x4330000000000000ULL | (duk_uint64_t) tv->v.fi;
-+		DUK_DBLUNION_SET_UINT64(&du, t);
-+		return du.d - 4503599627370496.0;  /* 1 << 52 */
-+	} else {
-+		t = 0xc330000000000000ULL | (duk_uint64_t) (-tv->v.fi);
-+		DUK_DBLUNION_SET_UINT64(&du, t);
-+		return du.d + 4503599627370496.0;  /* 1 << 52 */
-+	}
-+}
-+#endif  /* DUK_USE_FASTINT && DUK_USE_PACKED_TVAL */
-+
-+#endif  /* DUK_USE_FASTINT */
-+#line 1 "duk_unicode_tables.c"
-+/*
-+ *  Unicode support tables automatically generated during build.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/*
-+ *  Unicode tables containing ranges of Unicode characters in a
-+ *  packed format.  These tables are used to match non-ASCII
-+ *  characters of complex productions by resorting to a linear
-+ *  range-by-range comparison.  This is very slow, but is expected
-+ *  to be very rare in practical Ecmascript source code, and thus
-+ *  compactness is most important.
-+ *
-+ *  The tables are matched using uni_range_match() and the format
-+ *  is described in src/extract_chars.py.
-+ */
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+/* IdentifierStart production with ASCII excluded */
-+/* duk_unicode_ids_noa[] */
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+const duk_uint8_t duk_unicode_ids_noa[791] = {
-+249,176,176,80,111,7,47,15,47,254,11,197,191,0,72,2,15,115,66,19,57,2,34,2,
-+240,66,244,50,247,185,248,234,241,99,8,241,127,58,240,182,47,31,241,191,21,
-+18,245,50,15,1,24,27,35,15,2,2,240,239,15,244,156,15,10,241,26,21,6,240,
-+101,10,4,15,9,240,159,157,242,100,15,4,8,159,1,98,102,115,19,240,98,98,4,
-+52,15,2,14,18,47,0,31,5,85,19,240,98,98,18,18,31,17,50,15,5,47,2,130,34,
-+240,98,98,18,68,15,4,15,1,31,21,115,19,240,98,98,18,68,15,16,18,47,1,15,3,
-+2,84,34,52,18,2,20,20,36,191,8,15,38,114,34,240,114,146,68,15,12,23,31,21,
-+114,34,240,114,146,68,15,18,2,31,1,31,4,114,34,241,147,15,2,15,3,31,10,86,
-+240,36,240,130,130,3,111,44,242,2,29,111,44,18,3,18,3,7,50,98,34,2,3,18,50,
-+26,3,66,15,7,31,20,15,49,114,241,79,13,79,101,241,191,6,15,2,85,52,4,24,37,
-+205,15,3,241,107,241,178,4,255,224,59,35,54,32,35,63,25,35,63,17,35,54,32,
-+35,62,47,41,35,63,51,241,127,0,240,47,69,223,254,21,227,240,18,240,166,243,
-+180,47,1,194,63,0,240,47,0,240,47,0,194,47,1,242,79,21,5,15,53,244,137,241,
-+146,6,243,107,240,223,37,240,227,76,241,207,7,111,42,240,122,242,95,68,15,
-+79,241,255,3,111,41,240,238,31,2,241,111,12,241,79,27,43,241,79,93,50,63,0,
-+251,15,50,255,224,8,53,63,22,53,55,32,32,32,47,15,63,37,38,32,66,38,67,53,
-+92,98,38,246,96,224,240,44,245,112,80,57,32,68,112,32,32,35,42,51,100,80,
-+240,63,25,255,233,107,241,242,241,242,247,87,63,3,241,107,242,106,15,2,240,
-+122,98,98,98,98,98,98,98,111,66,15,254,12,146,240,184,132,52,95,70,114,47,
-+74,35,111,25,79,78,240,63,11,242,127,0,255,224,244,255,240,0,138,143,60,
-+255,240,4,11,239,38,255,227,127,243,95,30,63,253,79,0,177,240,111,31,240,
-+47,9,159,64,241,152,63,87,51,33,240,9,244,39,34,35,47,7,240,255,36,240,15,
-+34,243,5,64,240,15,12,191,7,240,191,13,143,31,240,224,242,47,25,240,146,39,
-+240,111,7,64,111,32,32,65,52,48,32,240,162,241,85,53,53,166,38,248,63,19,
-+240,255,255,0,26,150,223,7,95,33,255,240,0,255,143,254,2,3,242,227,245,175,
-+24,109,70,2,146,194,66,2,18,18,245,207,19,255,224,93,240,79,48,63,38,241,
-+171,246,100,47,119,241,111,10,127,10,207,73,69,53,53,50,241,91,47,10,47,3,
-+33,46,61,241,79,107,243,127,37,255,223,13,79,33,242,31,15,240,63,11,242,
-+127,14,63,20,87,36,241,207,142,255,226,86,83,2,241,194,20,3,240,127,156,
-+240,107,240,175,184,15,1,50,34,240,191,30,240,223,117,242,107,240,107,240,
-+63,127,243,159,254,42,239,37,243,223,29,255,238,68,255,226,97,248,63,83,
-+255,234,145,255,227,33,255,240,2,44,95,254,18,191,255,0,52,187,31,255,0,18,
-+242,244,82,243,114,19,3,19,50,178,2,98,243,18,51,114,98,240,194,50,66,4,98,
-+255,224,70,63,9,47,9,47,15,47,9,47,15,47,9,47,15,47,9,47,15,47,9,39,255,
-+240,1,114,143,255,0,149,201,241,191,254,242,124,252,239,255,0,46,214,255,
-+225,16,0,
-+};
-+#else
-+/* IdentifierStart production with ASCII and non-BMP excluded */
-+/* duk_unicode_ids_noabmp[] */
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+const duk_uint8_t duk_unicode_ids_noabmp[611] = {
-+249,176,176,80,111,7,47,15,47,254,11,197,191,0,72,2,15,115,66,19,57,2,34,2,
-+240,66,244,50,247,185,248,234,241,99,8,241,127,58,240,182,47,31,241,191,21,
-+18,245,50,15,1,24,27,35,15,2,2,240,239,15,244,156,15,10,241,26,21,6,240,
-+101,10,4,15,9,240,159,157,242,100,15,4,8,159,1,98,102,115,19,240,98,98,4,
-+52,15,2,14,18,47,0,31,5,85,19,240,98,98,18,18,31,17,50,15,5,47,2,130,34,
-+240,98,98,18,68,15,4,15,1,31,21,115,19,240,98,98,18,68,15,16,18,47,1,15,3,
-+2,84,34,52,18,2,20,20,36,191,8,15,38,114,34,240,114,146,68,15,12,23,31,21,
-+114,34,240,114,146,68,15,18,2,31,1,31,4,114,34,241,147,15,2,15,3,31,10,86,
-+240,36,240,130,130,3,111,44,242,2,29,111,44,18,3,18,3,7,50,98,34,2,3,18,50,
-+26,3,66,15,7,31,20,15,49,114,241,79,13,79,101,241,191,6,15,2,85,52,4,24,37,
-+205,15,3,241,107,241,178,4,255,224,59,35,54,32,35,63,25,35,63,17,35,54,32,
-+35,62,47,41,35,63,51,241,127,0,240,47,69,223,254,21,227,240,18,240,166,243,
-+180,47,1,194,63,0,240,47,0,240,47,0,194,47,1,242,79,21,5,15,53,244,137,241,
-+146,6,243,107,240,223,37,240,227,76,241,207,7,111,42,240,122,242,95,68,15,
-+79,241,255,3,111,41,240,238,31,2,241,111,12,241,79,27,43,241,79,93,50,63,0,
-+251,15,50,255,224,8,53,63,22,53,55,32,32,32,47,15,63,37,38,32,66,38,67,53,
-+92,98,38,246,96,224,240,44,245,112,80,57,32,68,112,32,32,35,42,51,100,80,
-+240,63,25,255,233,107,241,242,241,242,247,87,63,3,241,107,242,106,15,2,240,
-+122,98,98,98,98,98,98,98,111,66,15,254,12,146,240,184,132,52,95,70,114,47,
-+74,35,111,25,79,78,240,63,11,242,127,0,255,224,244,255,240,0,138,143,60,
-+255,240,4,11,239,38,255,227,127,243,95,30,63,253,79,0,177,240,111,31,240,
-+47,9,159,64,241,152,63,87,51,33,240,9,244,39,34,35,47,7,240,255,36,240,15,
-+34,243,5,64,240,15,12,191,7,240,191,13,143,31,240,224,242,47,25,240,146,39,
-+240,111,7,64,111,32,32,65,52,48,32,240,162,241,85,53,53,166,38,248,63,19,
-+240,255,255,0,26,150,223,7,95,33,255,240,0,255,143,254,2,3,242,227,245,175,
-+24,109,70,2,146,194,66,2,18,18,245,207,19,255,224,93,240,79,48,63,38,241,
-+171,246,100,47,119,241,111,10,127,10,207,73,69,53,53,50,0,
-+};
-+#endif
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+/* IdentifierStart production with Letter and ASCII excluded */
-+/* duk_unicode_ids_m_let_noa[] */
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+const duk_uint8_t duk_unicode_ids_m_let_noa[42] = {
-+255,240,0,94,18,255,233,99,241,51,63,254,215,32,240,184,240,2,255,240,6,89,
-+249,255,240,4,148,79,37,255,224,192,9,15,120,79,255,0,15,30,245,48,
-+};
-+#else
-+/* IdentifierStart production with Letter, ASCII, and non-BMP excluded */
-+/* duk_unicode_ids_m_let_noabmp[] */
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+const duk_uint8_t duk_unicode_ids_m_let_noabmp[24] = {
-+255,240,0,94,18,255,233,99,241,51,63,254,215,32,240,184,240,2,255,240,6,89,
-+249,0,
-+};
-+#endif
-+
-+#ifdef DUK_USE_SOURCE_NONBMP
-+/* IdentifierPart production with IdentifierStart and ASCII excluded */
-+/* duk_unicode_idp_m_ids_noa[] */
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+const duk_uint8_t duk_unicode_idp_m_ids_noa[397] = {
-+255,225,243,246,15,254,0,116,255,191,29,32,33,33,32,243,170,242,47,15,112,
-+245,118,53,49,35,57,240,144,241,15,11,244,218,240,25,241,56,241,67,40,34,
-+36,241,210,249,99,242,130,47,2,38,177,57,240,50,242,160,38,49,50,160,177,
-+57,240,50,242,160,36,81,50,64,240,107,64,194,242,160,39,34,34,240,97,57,
-+240,50,242,160,38,49,50,145,177,57,240,64,242,212,66,35,160,240,9,240,50,
-+242,198,34,35,129,193,57,240,65,242,160,38,34,35,129,193,57,240,65,242,198,
-+34,35,160,177,57,240,65,243,128,85,32,39,240,65,242,240,54,215,41,244,144,
-+53,33,197,57,243,1,121,192,32,32,81,242,63,4,33,106,47,20,160,245,111,4,41,
-+211,82,34,54,67,235,46,255,225,179,47,254,42,98,240,242,240,241,241,1,243,
-+79,14,160,57,241,50,57,248,16,246,139,91,185,245,47,1,129,121,242,244,242,
-+185,47,13,58,121,245,132,242,31,1,201,240,56,210,241,9,105,241,237,242,47,
-+4,153,121,246,130,47,5,80,80,251,255,23,240,115,255,225,0,31,35,31,5,15,
-+109,197,4,191,254,175,34,247,240,245,47,16,255,225,30,95,91,31,255,0,100,
-+121,159,55,13,31,100,31,254,0,64,64,80,240,148,244,161,242,79,1,201,127,2,
-+240,9,240,231,240,188,241,227,242,29,240,25,244,29,208,145,57,241,48,242,
-+96,34,49,97,32,255,224,21,114,19,159,255,0,62,24,15,254,29,95,0,240,38,209,
-+240,162,251,41,241,112,255,225,177,15,254,25,105,255,228,75,34,22,63,26,37,
-+15,254,75,66,242,126,241,25,240,34,241,250,255,240,10,249,228,69,151,54,
-+241,3,248,98,255,228,125,242,47,255,12,23,244,254,0,
-+};
-+#else
-+/* IdentifierPart production with IdentifierStart, ASCII, and non-BMP excluded */
-+/* duk_unicode_idp_m_ids_noabmp[] */
-+/*
-+ *  Automatically generated by extract_chars.py, do not edit!
-+ */
-+
-+const duk_uint8_t duk_unicode_idp_m_ids_noabmp[348] = {
-+255,225,243,246,15,254,0,116,255,191,29,32,33,33,32,243,170,242,47,15,112,
-+245,118,53,49,35,57,240,144,241,15,11,244,218,240,25,241,56,241,67,40,34,
-+36,241,210,249,99,242,130,47,2,38,177,57,240,50,242,160,38,49,50,160,177,
-+57,240,50,242,160,36,81,50,64,240,107,64,194,242,160,39,34,34,240,97,57,
-+240,50,242,160,38,49,50,145,177,57,240,64,242,212,66,35,160,240,9,240,50,
-+242,198,34,35,129,193,57,240,65,242,160,38,34,35,129,193,57,240,65,242,198,
-+34,35,160,177,57,240,65,243,128,85,32,39,240,65,242,240,54,215,41,244,144,
-+53,33,197,57,243,1,121,192,32,32,81,242,63,4,33,106,47,20,160,245,111,4,41,
-+211,82,34,54,67,235,46,255,225,179,47,254,42,98,240,242,240,241,241,1,243,
-+79,14,160,57,241,50,57,248,16,246,139,91,185,245,47,1,129,121,242,244,242,
-+185,47,13,58,121,245,132,242,31,1,201,240,56,210,241,9,105,241,237,242,47,
-+4,153,121,246,130,47,5,80,80,251,255,23,240,115,255,225,0,31,35,31,5,15,
-+109,197,4,191,254,175,34,247,240,245,47,16,255,225,30,95,91,31,255,0,100,
-+121,159,55,13,31,100,31,254,0,64,64,80,240,148,244,161,242,79,1,201,127,2,
-+240,9,240,231,240,188,241,227,242,29,240,25,244,29,208,145,57,241,48,242,
-+96,34,49,97,32,255,224,21,114,19,159,255,0,62,24,15,254,29,95,0,240,38,209,
-+240,162,251,41,241,112,0,
-+};
-+#endif
-+
-+/*
-+ *  Case conversion tables generated using src/extract_caseconv.py.
-+ */
-+
-+/* duk_unicode_caseconv_uc[] */
-+/* duk_unicode_caseconv_lc[] */
-+
-+/*
-+ *  Automatically generated by extract_caseconv.py, do not edit!
-+ */
-+
-+const duk_uint8_t duk_unicode_caseconv_uc[1288] = {
-+132,3,128,3,0,184,7,192,6,192,112,35,242,199,224,64,74,192,49,32,128,162,
-+128,108,65,1,189,129,254,131,3,173,3,136,6,7,98,7,34,68,15,12,14,140,72,30,
-+104,28,112,32,67,0,65,4,0,138,0,128,4,1,88,65,76,83,15,128,15,132,8,31,16,
-+31,24,12,62,64,62,80,32,124,192,124,224,64,250,0,250,64,97,246,1,246,129,3,
-+238,3,247,64,135,220,135,242,2,15,187,15,237,2,31,120,31,248,4,62,244,63,
-+212,8,125,240,127,232,16,253,128,253,192,33,253,1,253,128,67,252,3,253,0,
-+136,92,8,88,8,18,104,18,91,26,44,48,44,0,94,90,0,33,64,155,253,7,252,132,
-+212,0,32,32,32,6,0,76,192,76,129,128,157,0,156,136,1,75,1,74,46,2,244,2,
-+242,12,6,12,6,8,16,13,8,13,0,48,27,64,27,48,64,57,192,57,162,0,119,192,119,
-+132,128,252,128,252,20,2,35,2,34,18,4,142,4,140,20,13,196,13,192,16,30,200,
-+30,192,192,70,16,70,2,32,145,96,145,70,193,48,129,48,67,130,104,130,104,44,
-+30,1,30,0,150,61,66,61,64,192,125,68,125,100,33,99,65,99,56,50,200,18,200,
-+6,69,157,133,157,96,169,144,105,144,11,211,64,211,64,12,167,35,167,34,15,
-+78,103,78,100,126,157,234,157,228,21,59,253,59,240,90,122,26,122,0,163,128,
-+214,128,214,2,1,197,1,196,6,3,140,3,136,12,7,200,7,196,16,20,0,13,48,32,63,
-+128,63,112,69,142,101,142,64,130,1,136,1,135,4,3,114,3,112,8,26,120,202,
-+120,176,65,1,30,1,29,130,2,105,1,150,5,255,96,22,160,115,128,31,224,47,0,
-+38,32,9,32,47,224,10,96,48,0,72,96,50,64,50,32,50,160,62,192,51,32,51,0,51,
-+64,71,160,51,192,68,0,53,0,52,224,55,224,62,224,59,160,49,192,62,96,62,32,
-+74,5,141,224,74,37,141,160,74,69,142,0,74,96,48,32,74,128,48,192,75,32,49,
-+224,75,96,50,0,76,0,50,96,76,96,50,128,76,180,241,160,77,0,50,224,77,101,
-+140,64,78,37,141,192,78,64,51,160,78,160,51,224,79,165,140,128,81,0,53,192,
-+81,32,72,128,81,128,72,160,82,64,54,224,104,160,115,32,110,224,110,192,117,
-+128,112,192,120,64,116,96,121,128,113,128,122,0,114,64,122,32,115,0,122,
-+160,116,192,122,192,116,0,122,224,121,224,126,0,115,64,126,32,116,32,126,
-+64,127,32,126,160,114,160,153,224,152,3,175,52,239,163,175,165,140,99,211,
-+99,204,3,247,192,115,35,252,163,253,132,41,196,38,68,48,132,48,101,140,37,
-+140,5,140,160,71,69,140,192,71,217,128,55,224,5,48,5,48,20,152,10,240,1,56,
-+7,194,0,74,3,12,3,144,192,230,64,194,0,192,64,236,48,58,80,48,128,48,16,88,
-+120,20,212,21,72,122,90,0,72,3,49,30,151,128,21,0,194,7,166,32,5,112,48,
-+161,233,152,1,100,12,40,122,106,0,65,2,190,31,80,128,233,64,196,199,212,
-+176,58,80,49,48,48,1,245,76,14,148,12,76,12,4,125,91,3,165,3,19,3,66,31,
-+128,135,194,0,230,71,224,97,240,144,57,145,248,40,124,40,14,100,126,14,31,
-+11,3,153,31,132,135,195,0,230,71,225,97,240,208,57,145,248,104,124,56,14,
-+100,126,30,31,15,3,153,31,136,135,194,0,230,71,226,97,240,144,57,145,248,
-+168,124,40,14,100,126,46,31,11,3,153,31,140,135,195,0,230,71,227,97,240,
-+208,57,145,248,232,124,56,14,100,126,62,31,15,3,153,31,144,135,202,0,230,
-+71,228,97,242,144,57,145,249,40,124,168,14,100,126,78,31,43,3,153,31,148,
-+135,203,0,230,71,229,97,242,208,57,145,249,104,124,184,14,100,126,94,31,47,
-+3,153,31,152,135,202,0,230,71,230,97,242,144,57,145,249,168,124,168,14,100,
-+126,110,31,43,3,153,31,156,135,203,0,230,71,231,97,242,208,57,145,249,232,
-+124,184,14,100,126,126,31,47,3,153,31,160,135,218,0,230,71,232,97,246,144,
-+57,145,250,40,125,168,14,100,126,142,31,107,3,153,31,164,135,219,0,230,71,
-+233,97,246,208,57,145,250,104,125,184,14,100,126,158,31,111,3,153,31,168,
-+135,218,0,230,71,234,97,246,144,57,145,250,168,125,168,14,100,126,174,31,
-+107,3,153,31,172,135,219,0,230,71,235,97,246,208,57,145,250,232,125,184,14,
-+100,126,190,31,111,3,153,31,178,135,238,128,230,71,236,224,57,16,57,145,
-+251,72,14,24,14,100,126,218,3,145,3,66,31,183,192,228,64,208,128,230,71,
-+239,32,57,16,57,145,252,40,127,40,14,100,127,14,3,151,3,153,31,196,128,226,
-+64,230,71,241,160,57,112,52,33,252,124,14,92,13,8,14,100,127,50,3,151,3,
-+153,31,210,192,230,64,194,0,192,7,244,240,57,144,48,128,48,17,253,104,14,
-+100,13,8,127,95,3,153,3,8,3,66,31,226,192,233,64,194,0,192,7,248,240,58,80,
-+48,128,48,17,254,72,14,132,12,76,127,154,3,165,3,66,31,231,192,233,64,194,
-+0,208,135,252,161,255,160,57,145,255,56,14,164,14,100,127,210,3,143,3,153,
-+31,246,128,234,64,208,135,253,240,58,144,52,32,57,145,255,200,14,164,14,
-+103,236,2,0,70,0,70,251,1,128,17,128,18,126,192,160,4,96,4,207,176,60,1,24,
-+1,24,1,39,236,19,0,70,0,70,0,76,251,5,128,20,192,21,62,193,160,5,48,5,79,
-+177,56,21,16,21,27,236,82,5,68,5,53,251,21,129,81,1,78,254,197,160,84,224,
-+84,111,177,120,21,16,20,244,
-+};
-+const duk_uint8_t duk_unicode_caseconv_lc[616] = {
-+144,3,0,3,128,184,6,192,7,192,112,24,144,37,96,64,54,32,81,64,128,226,0,
-+235,65,129,199,1,230,130,3,145,3,177,34,7,70,7,134,36,15,244,13,236,24,32,
-+0,34,129,0,65,0,67,4,0,166,32,172,41,132,40,11,64,19,15,132,15,128,8,31,24,
-+31,16,12,62,80,62,64,32,124,224,124,192,64,250,64,250,0,97,246,129,246,1,3,
-+241,3,240,2,7,230,7,228,4,15,212,15,208,8,31,184,31,176,4,63,116,62,224,8,
-+127,32,125,200,32,254,192,254,128,33,253,161,247,96,67,253,3,252,0,135,250,
-+135,222,129,15,252,15,188,2,31,250,31,124,4,66,192,66,224,64,146,216,147,
-+64,209,96,1,97,130,242,199,224,35,240,95,228,63,232,38,161,1,0,1,1,48,2,
-+100,2,102,12,4,228,4,232,64,10,80,10,89,112,23,144,23,160,96,48,64,48,96,
-+128,104,0,104,65,128,217,128,218,2,1,203,1,204,18,3,188,3,190,36,7,200,7,
-+204,16,15,192,15,201,64,34,32,34,49,32,72,192,72,225,64,220,0,220,65,1,236,
-+1,236,140,4,96,4,97,34,9,20,9,22,108,19,4,19,8,56,38,128,38,138,193,224,1,
-+224,25,99,212,3,212,44,7,214,71,212,66,22,51,150,52,3,44,128,44,129,100,89,
-+214,89,216,10,153,2,153,4,189,52,5,52,8,202,114,42,114,48,244,230,84,230,
-+103,233,222,105,222,129,83,191,83,191,133,167,160,167,161,10,48,13,48,20,0,
-+32,26,192,26,208,64,56,128,56,192,192,113,64,113,129,1,251,129,252,2,44,
-+114,44,115,4,16,12,56,12,64,32,27,128,27,144,64,211,197,211,198,2,8,6,88,9,
-+164,16,17,216,17,224,47,245,1,120,0,255,1,129,2,83,1,134,2,84,1,142,1,221,
-+1,143,2,89,1,144,2,91,1,145,1,146,1,147,2,96,1,148,2,99,1,151,2,104,1,152,
-+1,153,1,157,2,114,1,159,2,117,1,167,1,168,1,174,2,136,1,183,2,146,1,241,1,
-+243,1,246,1,149,1,247,1,191,2,32,1,158,2,58,44,101,2,61,1,154,2,62,44,102,
-+2,67,1,128,2,68,2,137,2,69,2,140,3,118,3,119,3,134,3,172,3,140,3,204,3,207,
-+3,215,3,244,3,184,3,249,3,242,4,192,4,207,30,158,0,223,31,188,31,179,31,
-+204,31,195,31,236,31,229,31,252,31,243,33,38,3,201,33,42,0,107,33,43,0,229,
-+33,50,33,78,33,131,33,132,44,96,44,97,44,98,2,107,44,99,29,125,44,100,2,
-+125,44,109,2,81,44,110,2,113,44,111,2,80,44,112,2,82,167,125,29,121,167,
-+141,2,101,2,2,97,0,52,129,131,128,
-+};
-+#line 1 "duk_util_bitdecoder.c"
-+/*
-+ *  Bitstream decoder.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* Decode 'bits' bits from the input stream (bits must be 1...24).
-+ * When reading past bitstream end, zeroes are shifted in.  The result
-+ * is signed to match duk_bd_decode_flagged.
-+ */
-+DUK_INTERNAL duk_int32_t duk_bd_decode(duk_bitdecoder_ctx *ctx, duk_small_int_t bits) {
-+	duk_small_int_t shift;
-+	duk_uint32_t mask;
-+	duk_uint32_t tmp;
-+
-+	/* Note: cannot read more than 24 bits without possibly shifting top bits out.
-+	 * Fixable, but adds complexity.
-+	 */
-+	DUK_ASSERT(bits >= 1 && bits <= 24);
-+
-+	while (ctx->currbits < bits) {
-+#if 0
-+		DUK_DDD(DUK_DDDPRINT("decode_bits: shift more data (bits=%ld, currbits=%ld)",
-+		                     (long) bits, (long) ctx->currbits));
-+#endif
-+		ctx->currval <<= 8;
-+		if (ctx->offset < ctx->length) {
-+			/* If ctx->offset >= ctx->length, we "shift zeroes in"
-+			 * instead of croaking.
-+			 */
-+			ctx->currval |= ctx->data[ctx->offset++];
-+		}
-+		ctx->currbits += 8;
-+	}
-+#if 0
-+	DUK_DDD(DUK_DDDPRINT("decode_bits: bits=%ld, currbits=%ld, currval=0x%08lx",
-+	                     (long) bits, (long) ctx->currbits, (unsigned long) ctx->currval));
-+#endif
-+
-+	/* Extract 'top' bits of currval; note that the extracted bits do not need
-+	 * to be cleared, we just ignore them on next round.
-+	 */
-+	shift = ctx->currbits - bits;
-+	mask = (1 << bits) - 1;
-+	tmp = (ctx->currval >> shift) & mask;
-+	ctx->currbits = shift;  /* remaining */
-+
-+#if 0
-+	DUK_DDD(DUK_DDDPRINT("decode_bits: %ld bits -> 0x%08lx (%ld), currbits=%ld, currval=0x%08lx",
-+	                     (long) bits, (unsigned long) tmp, (long) tmp, (long) ctx->currbits, (unsigned long) ctx->currval));
-+#endif
-+
-+	return tmp;
-+}
-+
-+DUK_INTERNAL duk_small_int_t duk_bd_decode_flag(duk_bitdecoder_ctx *ctx) {
-+	return (duk_small_int_t) duk_bd_decode(ctx, 1);
-+}
-+
-+/* Decode a one-bit flag, and if set, decode a value of 'bits', otherwise return
-+ * default value.  Return value is signed so that negative marker value can be
-+ * used by caller as a "not present" value.
-+ */
-+DUK_INTERNAL duk_int32_t duk_bd_decode_flagged(duk_bitdecoder_ctx *ctx, duk_small_int_t bits, duk_int32_t def_value) {
-+	if (duk_bd_decode_flag(ctx)) {
-+		return (duk_int32_t) duk_bd_decode(ctx, bits);
-+	} else {
-+		return def_value;
-+	}
-+}
-+#line 1 "duk_util_bitencoder.c"
-+/*
-+ *  Bitstream encoder.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+DUK_INTERNAL void duk_be_encode(duk_bitencoder_ctx *ctx, duk_uint32_t data, duk_small_int_t bits) {
-+	duk_uint8_t tmp;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(ctx->currbits < 8);
-+
-+	/* This limitation would be fixable but adds unnecessary complexity. */
-+	DUK_ASSERT(bits >= 1 && bits <= 24);
-+
-+	ctx->currval = (ctx->currval << bits) | data;
-+	ctx->currbits += bits;
-+
-+	while (ctx->currbits >= 8) {
-+		if (ctx->offset < ctx->length) {
-+			tmp = (duk_uint8_t) ((ctx->currval >> (ctx->currbits - 8)) & 0xff);
-+			ctx->data[ctx->offset++] = tmp;
-+		} else {
-+			/* If buffer has been exhausted, truncate bitstream */
-+			ctx->truncated = 1;
-+		}
-+
-+		ctx->currbits -= 8;
-+	}
-+}
-+
-+DUK_INTERNAL void duk_be_finish(duk_bitencoder_ctx *ctx) {
-+	duk_small_int_t npad;
-+
-+	DUK_ASSERT(ctx != NULL);
-+	DUK_ASSERT(ctx->currbits < 8);
-+
-+	npad = (duk_small_int_t) (8 - ctx->currbits);
-+	if (npad > 0) {
-+		duk_be_encode(ctx, 0, npad);
-+	}
-+	DUK_ASSERT(ctx->currbits == 0);
-+}
-+#line 1 "duk_util_hashbytes.c"
-+/*
-+ *  Hash function duk_util_hashbytes().
-+ *
-+ *  Currently, 32-bit MurmurHash2.
-+ *
-+ *  Don't rely on specific hash values; hash function may be endianness
-+ *  dependent, for instance.
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+/* 'magic' constants for Murmurhash2 */
-+#define DUK__MAGIC_M  ((duk_uint32_t) 0x5bd1e995UL)
-+#define DUK__MAGIC_R  24
-+
-+DUK_INTERNAL duk_uint32_t duk_util_hashbytes(const duk_uint8_t *data, duk_size_t len, duk_uint32_t seed) {
-+	duk_uint32_t h = seed ^ ((duk_uint32_t) len);
-+
-+	while (len >= 4) {
-+		/* Portability workaround is required for platforms without
-+		 * unaligned access.  The replacement code emulates little
-+		 * endian access even on big endian architectures, which is
-+		 * OK as long as it is consistent for a build.
-+		 */
-+#ifdef DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS
-+		duk_uint32_t k = *((duk_uint32_t *) data);
-+#else
-+		duk_uint32_t k = ((duk_uint32_t) data[0]) |
-+		                 (((duk_uint32_t) data[1]) << 8) |
-+		                 (((duk_uint32_t) data[2]) << 16) |
-+		                 (((duk_uint32_t) data[3]) << 24);
-+#endif
-+
-+		k *= DUK__MAGIC_M;
-+		k ^= k >> DUK__MAGIC_R;
-+		k *= DUK__MAGIC_M;
-+		h *= DUK__MAGIC_M;
-+		h ^= k;
-+		data += 4;
-+		len -= 4;
-+	}
-+
-+	switch (len) {
-+	case 3: h ^= data[2] << 16;
-+	case 2: h ^= data[1] << 8;
-+	case 1: h ^= data[0];
-+	        h *= DUK__MAGIC_M;
-+        }
-+
-+	h ^= h >> 13;
-+	h *= DUK__MAGIC_M;
-+	h ^= h >> 15;
-+
-+	return h;
-+}
-+#line 1 "duk_util_tinyrandom.c"
-+/*
-+ *  A tiny random number generator.
-+ *
-+ *  Currently used for Math.random().
-+ *
-+ *  http://www.woodmann.com/forum/archive/index.php/t-3100.html
-+ */
-+
-+/* include removed: duk_internal.h */
-+
-+#define DUK__UPDATE_RND(rnd) do { \
-+		(rnd) += ((rnd) * (rnd)) | 0x05; \
-+		(rnd) = ((rnd) & 0xffffffffU);       /* if duk_uint32_t is exactly 32 bits, this is a NOP */ \
-+	} while (0)
-+
-+#define DUK__RND_BIT(rnd)  ((rnd) >> 31)  /* only use the highest bit */
-+
-+DUK_INTERNAL duk_uint32_t duk_util_tinyrandom_get_bits(duk_hthread *thr, duk_small_int_t n) {
-+	duk_small_int_t i;
-+	duk_uint32_t res = 0;
-+	duk_uint32_t rnd;
-+
-+	rnd = thr->heap->rnd_state;
-+
-+	for (i = 0; i < n; i++) {
-+		DUK__UPDATE_RND(rnd);
-+		res <<= 1;
-+		res += DUK__RND_BIT(rnd);
-+	}
-+
-+	thr->heap->rnd_state = rnd;
-+
-+	return res;
-+}
-+
-+DUK_INTERNAL duk_double_t duk_util_tinyrandom_get_double(duk_hthread *thr) {
-+	duk_double_t t;
-+	duk_small_int_t n;
-+	duk_uint32_t rnd;
-+
-+	/*
-+	 *  XXX: could make this a lot faster if we create the double memory
-+	 *  representation directly.  Feasible easily (must be uniform random).
-+	 */
-+
-+	rnd = thr->heap->rnd_state;
-+
-+	n = 53;  /* enough to cover the whole mantissa */
-+	t = 0.0;
-+
-+	do {
-+		DUK__UPDATE_RND(rnd);
-+		t += DUK__RND_BIT(rnd);
-+		t /= 2.0;
-+	} while (--n);
-+
-+	thr->heap->rnd_state = rnd;
-+
-+	DUK_ASSERT(t >= (duk_double_t) 0.0);
-+	DUK_ASSERT(t < (duk_double_t) 1.0);
-+
-+	return t;
-+}
-diff --git a/src/polkitbackend/duktape.h b/src/polkitbackend/duktape.h
-new file mode 100644
-index 0000000..493129b
---- /dev/null
-+++ b/src/polkitbackend/duktape.h
-@@ -0,0 +1,4460 @@
-+/*
-+ *  Duktape public API for Duktape 1.2.3.
-+ *  See the API reference for documentation on call semantics.
-+ *  The exposed API is inside the DUK_API_PUBLIC_H_INCLUDED
-+ *  include guard.  Other parts of the header are Duktape
-+ *  internal and related to platform/compiler/feature detection.
-+ *
-+ *  Git commit 0605a18660dbae486c62a42a33fabd034c8623ff (v1.2.3).
-+ *
-+ *  See Duktape AUTHORS.rst and LICENSE.txt for copyright and
-+ *  licensing information.
-+ */
-+
-+/* LICENSE.txt */
-+/*
-+ *  ===============
-+ *  Duktape license
-+ *  ===============
-+ *  
-+ *  (http://opensource.org/licenses/MIT)
-+ *  
-+ *  Copyright (c) 2013-2015 by Duktape authors (see AUTHORS.rst)
-+ *  
-+ *  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.
-+ *  
-+ */
-+
-+/* AUTHORS.rst */
-+/*
-+ *  ===============
-+ *  Duktape authors
-+ *  ===============
-+ *  
-+ *  Copyright
-+ *  =========
-+ *  
-+ *  Duktape copyrights are held by its authors.  Each author has a copyright
-+ *  to their contribution, and agrees to irrevocably license the contribution
-+ *  under the Duktape ``LICENSE.txt``.
-+ *  
-+ *  Authors
-+ *  =======
-+ *  
-+ *  Please include an e-mail address, a link to your GitHub profile, or something
-+ *  similar to allow your contribution to be identified accurately.
-+ *  
-+ *  The following people have contributed code and agreed to irrevocably license
-+ *  their contributions under the Duktape ``LICENSE.txt`` (in order of appearance):
-+ *  
-+ *  * Sami Vaarala <[email protected]>
-+ *  * Niki Dobrev
-+ *  * Andreas \u00d6man <[email protected]>
-+ *  * L\u00e1szl\u00f3 Lang\u00f3 <[email protected]>
-+ *  * Legimet <[email protected]>
-+ *  
-+ *  Other contributions
-+ *  ===================
-+ *  
-+ *  The following people have contributed something other than code (e.g. reported
-+ *  bugs, provided ideas, etc; roughly in order of appearance):
-+ *  
-+ *  * Greg Burns
-+ *  * Anthony Rabine
-+ *  * Carlos Costa
-+ *  * Aur\u00e9lien Bouilland
-+ *  * Preet Desai (Pris Matic)
-+ *  * judofyr (http://www.reddit.com/user/judofyr)
-+ *  * Jason Woofenden
-+ *  * Micha\u0142 Przyby\u015b
-+ *  * Anthony Howe
-+ *  * Conrad Pankoff
-+ *  * Jim Schimpf
-+ *  * Rajaran Gaunker (https://github.com/zimbabao)
-+ *  * Andreas \u00d6man
-+ *  * Doug Sanden
-+ *  * Josh Engebretson (https://github.com/JoshEngebretson)
-+ *  * Remo Eichenberger (https://github.com/remoe)
-+ *  * Mamod Mehyar (https://github.com/mamod)
-+ *  * David Demelier (https://github.com/hftmarkand)
-+ *  * Tim Caswell (https://github.com/creationix)
-+ *  * Mitchell Blank Jr (https://github.com/mitchblank)
-+ *  * https://github.com/yushli
-+ *  * Seo Sanghyeon (https://github.com/sanxiyn)
-+ *  * Han ChoongWoo (https://github.com/tunz)
-+ *  * Joshua Peek (https://github.com/josh)
-+ *  * Bruce E. Pascoe (https://github.com/fatcerberus)
-+ *  * https://github.com/Kelledin
-+ *  * https://github.com/sstruchtrup
-+ *  
-+ *  If you are accidentally missing from this list, send me an e-mail
-+ *  (``[email protected]``) and I'll fix the omission.
-+ */
-+
-+#ifndef DUKTAPE_H_INCLUDED
-+#define DUKTAPE_H_INCLUDED
-+
-+#define DUK_SINGLE_FILE
-+
-+/*
-+ *  Determine platform features, select feature selection defines
-+ *  (e.g. _XOPEN_SOURCE), include system headers, and define DUK_USE_XXX
-+ *  defines which are (only) checked in Duktape internal code for
-+ *  activated features.  Duktape feature selection is based on automatic
-+ *  feature detection, user supplied DUK_OPT_xxx defines, and optionally
-+ *  a "duk_custom.h" user header (if DUK_OPT_HAVE_CUSTOM_H is defined).
-+ *
-+ *  When compiling Duktape, DUK_COMPILING_DUKTAPE is set, and this file
-+ *  is included before any system headers are included.  Feature selection
-+ *  defines (e.g. _XOPEN_SOURCE) are defined here before any system headers
-+ *  are included (which is a requirement for system headers to work correctly).
-+ *  This file is responsible for including all system headers and contains
-+ *  all platform dependent cruft in general.  When compiling user code,
-+ *  DUK_COMPILING_DUKTAPE is not defined, and we must avoid e.g. defining
-+ *  unnecessary feature selection defines.
-+ *
-+ *  The general order of handling:
-+ *    - Compiler feature detection (require no includes)
-+ *    - Intermediate platform detection (-> easier platform defines)
-+ *    - Platform detection, system includes, byte order detection, etc
-+ *    - ANSI C wrappers (e.g. DUK_MEMCMP), wrappers for constants, etc
-+ *    - DUK_USE_xxx defines are resolved based on input defines
-+ *    - Duktape Date provider settings
-+ *    - Final sanity checks
-+ *
-+ *  DUK_F_XXX are internal feature detection macros which should not be
-+ *  used outside this header.
-+ *
-+ *  Useful resources:
-+ *
-+ *    http://sourceforge.net/p/predef/wiki/Home/
-+ *    http://sourceforge.net/p/predef/wiki/Architectures/
-+ *    http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor
-+ *    http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types
-+ *
-+ *  Preprocessor defines available in a particular GCC:
-+ *
-+ *    gcc -dM -E - </dev/null   # http://www.brain-dump.org/blog/entry/107
-+ */
-+
-+#ifndef DUK_FEATURES_H_INCLUDED
-+#define DUK_FEATURES_H_INCLUDED
-+
-+/*
-+ *  Compiler features
-+ */
-+
-+#undef DUK_F_C99
-+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
-+#define DUK_F_C99
-+#endif
-+
-+#undef DUK_F_CPP
-+#if defined(__cplusplus)
-+#define DUK_F_CPP
-+#endif
-+
-+#undef DUK_F_CPP11
-+#if defined(__cplusplus) && (__cplusplus >= 201103L)
-+#define DUK_F_CPP11
-+#endif
-+
-+/*
-+ *  Provides the duk_rdtsc() inline function (if available), limited to
-+ *  GCC C99.
-+ *
-+ *  See: http://www.mcs.anl.gov/~kazutomo/rdtsc.html
-+ */
-+
-+/* XXX: more accurate detection of what gcc versions work; more inline
-+ * asm versions for other compilers.
-+ */
-+#if defined(__GNUC__) && defined(__i386__) && defined(DUK_F_C99) && \
-+    !defined(__cplusplus) /* unsigned long long not standard */
-+static __inline__ unsigned long long duk_rdtsc(void) {
-+	unsigned long long int x;
-+	__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
-+	return x;
-+}
-+#define DUK_RDTSC_AVAILABLE 1
-+#elif defined(__GNUC__) && defined(__x86_64__) && defined(DUK_F_C99) && \
-+    !defined(__cplusplus) /* unsigned long long not standard */
-+static __inline__ unsigned long long duk_rdtsc(void) {
-+	unsigned hi, lo;
-+	__asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
-+	return ((unsigned long long) lo) | (((unsigned long long) hi) << 32);
-+}
-+#define DUK_RDTSC_AVAILABLE 1
-+#else
-+/* not available */
-+#undef DUK_RDTSC_AVAILABLE
-+#endif
-+
-+/*
-+ *  Intermediate platform, architecture, and compiler detection.  These are
-+ *  hopelessly intertwined - e.g. architecture defines depend on compiler etc.
-+ *
-+ *  Provide easier defines for platforms and compilers which are often tricky
-+ *  or verbose to detect.  The intent is not to provide intermediate defines for
-+ *  all features; only if existing feature defines are inconvenient.
-+ */
-+
-+/* Intel x86 (32-bit) */
-+#if defined(i386) || defined(__i386) || defined(__i386__) || \
-+    defined(__i486__) || defined(__i586__) || defined(__i686__) || \
-+    defined(__IA32__) || defined(_M_IX86) || defined(__X86__) || \
-+    defined(_X86_) || defined(__THW_INTEL__) || defined(__I86__)
-+#define DUK_F_X86
-+#endif
-+
-+/* AMD64 (64-bit) */
-+#if defined(__amd64__) || defined(__amd64) || \
-+    defined(__x86_64__) || defined(__x86_64) || \
-+    defined(_M_X64) || defined(_M_AMD64)
-+#define DUK_F_X64
-+#endif
-+
-+/* X32: 64-bit with 32-bit pointers (allows packed tvals).  X32 support is
-+ * not very mature yet.
-+ *
-+ * https://sites.google.com/site/x32abi/
-+ */
-+#if defined(DUK_F_X64) && \
-+    (defined(_ILP32) || defined(__ILP32__))
-+#define DUK_F_X32
-+/* define only one of: DUK_F_X86, DUK_F_X32, or DUK_F_X64 */
-+#undef DUK_F_X64
-+#undef DUK_F_X86
-+#endif
-+
-+/* ARM */
-+#if defined(__arm__) || defined(__thumb__) || defined(_ARM) || defined(_M_ARM)
-+#define DUK_F_ARM
-+#endif
-+
-+/* MIPS */
-+/* Related defines: __MIPSEB__, __MIPSEL__, __mips_isa_rev, __LP64__ */
-+#if defined(__mips__) || defined(mips) || defined(_MIPS_ISA) || \
-+    defined(_R3000) || defined(_R4000) || defined(_R5900) || \
-+    defined(_MIPS_ISA_MIPS1) || defined(_MIPS_ISA_MIPS2) || \
-+    defined(_MIPS_ISA_MIPS3) || defined(_MIPS_ISA_MIPS4) || \
-+    defined(__mips) || defined(__MIPS__)
-+#define DUK_F_MIPS
-+#if defined(__LP64__) || defined(__mips64) || defined(__mips64__) || \
-+    defined(__mips_n64)
-+#define DUK_F_MIPS64
-+#else
-+#define DUK_F_MIPS32
-+#endif
-+#endif
-+
-+/* SuperH */
-+#if defined(__sh__) || \
-+    defined(__sh1__) || defined(__SH1__) || \
-+    defined(__sh2__) || defined(__SH2__) || \
-+    defined(__sh3__) || defined(__SH3__) || \
-+    defined(__sh4__) || defined(__SH4__) || \
-+    defined(__sh5__) || defined(__SH5__)
-+#define DUK_F_SUPERH
-+#endif
-+
-+/* Motorola 68K.  Not defined by VBCC, so user must define one of these
-+ * manually when using VBCC.
-+ */
-+#if defined(__m68k__) || defined(M68000) || defined(__MC68K__)
-+#define DUK_F_M68K
-+#endif
-+
-+/* Linux */
-+#if defined(__linux) || defined(__linux__) || defined(linux)
-+#define DUK_F_LINUX
-+#endif
-+
-+/* FreeBSD */
-+#if defined(__FreeBSD__) || defined(__FreeBSD)
-+#define DUK_F_FREEBSD
-+#endif
-+
-+/* NetBSD */
-+#if defined(__NetBSD__) || defined(__NetBSD)
-+#define DUK_F_NETBSD
-+#endif
-+
-+/* OpenBSD */
-+#if defined(__OpenBSD__) || defined(__OpenBSD)
-+#define DUK_F_OPENBSD
-+#endif
-+
-+/* BSD variant */
-+#if defined(DUK_F_FREEBSD) || defined(DUK_F_NETBSD) || defined(DUK_F_OPENBSD) || \
-+    defined(__bsdi__) || defined(__DragonFly__)
-+#define DUK_F_BSD
-+#endif
-+
-+/* Generic Unix (includes Cygwin) */
-+#if defined(__unix) || defined(__unix__) || defined(unix) || \
-+    defined(DUK_F_LINUX) || defined(DUK_F_BSD)
-+#define DUK_F_UNIX
-+#endif
-+
-+/* Cygwin */
-+#if defined(__CYGWIN__)
-+#define DUK_F_CYGWIN
-+#endif
-+
-+/* Windows (32-bit or above) */
-+#if defined(_WIN32) || defined(WIN32) || defined(_WIN64) || defined(WIN64) || \
-+    defined(__WIN32__) || defined(__TOS_WIN__) || defined(__WINDOWS__)
-+#define DUK_F_WINDOWS
-+#endif
-+
-+#if defined(__APPLE__)
-+#define DUK_F_APPLE
-+#endif
-+
-+/* Atari ST TOS. __TOS__ defined by PureC (which doesn't work as a target now
-+ * because int is 16-bit, to be fixed).  No platform define in VBCC apparently,
-+ * so to use with VBCC, user must define '__TOS__' manually.
-+  */
-+#if defined(__TOS__)
-+#define DUK_F_TOS
-+#endif
-+
-+/* AmigaOS.  Neither AMIGA nor __amigaos__ is defined on VBCC, so user must
-+ * define 'AMIGA' manually.
-+ */
-+#if defined(AMIGA) || defined(__amigaos__)
-+#define DUK_F_AMIGAOS
-+#endif
-+
-+/* Flash player (e.g. Crossbridge) */
-+#if defined(__FLASHPLAYER__)
-+#define DUK_F_FLASHPLAYER
-+#endif
-+
-+/* Emscripten (provided explicitly by user), improve if possible */
-+#if defined(EMSCRIPTEN)
-+#define DUK_F_EMSCRIPTEN
-+#endif
-+
-+/* QNX */
-+#if defined(__QNX__)
-+#define DUK_F_QNX
-+#endif
-+
-+/* TI-Nspire (using Ndless) */
-+#if defined(_TINSPIRE)
-+#define DUK_F_TINSPIRE
-+#endif
-+
-+/* GCC and GCC version convenience define. */
-+#if defined(__GNUC__)
-+#define DUK_F_GCC
-+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
-+/* Convenience, e.g. gcc 4.5.1 == 40501; http://stackoverflow.com/questions/6031819/emulating-gccs-builtin-unreachable */
-+#define DUK_F_GCC_VERSION  (__GNUC__ * 10000L + __GNUC_MINOR__ * 100L + __GNUC_PATCHLEVEL__)
-+#else
-+#error cannot figure out gcc version
-+#endif
-+#endif
-+
-+/* Clang */
-+#if defined(__clang__)
-+#define DUK_F_CLANG
-+/* It seems clang also defines __GNUC__, so undo the GCC detection. */
-+#if defined(DUK_F_GCC)
-+#undef DUK_F_GCC
-+#endif
-+#if defined(DUK_F_GCC_VERSION)
-+#undef DUK_F_GCC_VERSION
-+#endif
-+#endif
-+
-+/* MSVC */
-+#if defined(_MSC_VER)
-+/* MSVC preprocessor defines: http://msdn.microsoft.com/en-us/library/b0084kay.aspx
-+ * _MSC_FULL_VER includes the build number, but it has at least two formats, see e.g.
-+ * BOOST_MSVC_FULL_VER in http://www.boost.org/doc/libs/1_52_0/boost/config/compiler/visualc.hpp
-+ */
-+#define DUK_F_MSVC
-+#if defined(_MSC_FULL_VER)
-+#if (_MSC_FULL_VER > 100000000)
-+#define DUK_F_MSVC_FULL_VER _MSC_FULL_VER
-+#else
-+#define DUK_F_MSCV_FULL_VER (_MSC_FULL_VER * 10)
-+#endif
-+#endif
-+#endif  /* _MSC_VER */
-+
-+/* MinGW */
-+#if defined(__MINGW32__) || defined(__MINGW64__)
-+/* NOTE: Also GCC flags are detected (DUK_F_GCC etc). */
-+#define DUK_F_MINGW
-+#endif
-+
-+/* BCC (Bruce's C compiler): this is a "torture target" for compilation */
-+#if defined(__BCC__) || defined(__BCC_VERSION__)
-+#define DUK_F_BCC
-+#endif
-+
-+#if defined(__VBCC__)
-+#define DUK_F_VBCC
-+#endif
-+
-+#if (defined(DUK_F_C99) || defined(DUK_F_CPP11)) && \
-+    !defined(DUK_F_BCC)
-+/* ULL / LL preprocessor constants should be avoided because they're not
-+ * always available.  With suitable options, some compilers will support
-+ * 64-bit integer types but won't support ULL / LL preprocessor constants.
-+ * Assume C99/C++11 environments have these.  However, BCC is nominally
-+ * C99 but doesn't support these constants.
-+ */
-+#define DUK_F_ULL_CONSTS
-+#endif
-+
-+/*
-+ *  Platform detection, system includes, Date provider selection.
-+ *
-+ *  Feature selection (e.g. _XOPEN_SOURCE) must happen before any system
-+ *  headers are included.  This header should avoid providing any feature
-+ *  selection defines when compiling user code (only when compiling Duktape
-+ *  itself).  If a feature selection option is required for user code to
-+ *  compile correctly (e.g. it is needed for type detection), it should
-+ *  probably be -checked- here, not defined here.
-+ *
-+ *  Date provider selection seems a bit out-of-place here, but since
-+ *  the date headers and provider functions are heavily platform
-+ *  specific, there's little point in duplicating the platform if-else
-+ *  ladder.  All platform specific Date provider functions are in
-+ *  duk_bi_date.c; here we provide appropriate #defines to enable them,
-+ *  and include all the necessary system headers so that duk_bi_date.c
-+ *  compiles.  Date "providers" are:
-+ *
-+ *    NOW = getting current time (required)
-+ *    TZO = getting local time offset (required)
-+ *    PRS = parse datetime (optional)
-+ *    FMT = format datetime (optional)
-+ *
-+ *  There's a lot of duplication here, unfortunately, because many
-+ *  platforms have similar (but not identical) headers, Date providers,
-+ *  etc.  The duplication could be removed by more complicated nested
-+ *  #ifdefs, but it would then be more difficult to make fixes which
-+ *  affect only a specific platform.
-+ *
-+ *  XXX: add a way to provide custom functions to provide the critical
-+ *  primitives; this would be convenient when porting to unknown platforms
-+ *  (rather than muck with Duktape internals).
-+ */
-+
-+#if defined(DUK_COMPILING_DUKTAPE) && \
-+ (defined(DUK_F_LINUX) || defined(DUK_F_EMSCRIPTEN))
-+/* A more recent Emscripten (2014-05) seems to lack "linux" environment
-+ * defines, so check for Emscripten explicitly.
-+ */
-+#ifndef _POSIX_C_SOURCE
-+#define _POSIX_C_SOURCE  200809L
-+#endif
-+#ifndef _GNU_SOURCE
-+#define _GNU_SOURCE      /* e.g. getdate_r */
-+#endif
-+#ifndef _XOPEN_SOURCE
-+#define _XOPEN_SOURCE    /* e.g. strptime */
-+#endif
-+#endif
-+
-+#if defined(DUK_F_QNX) && defined(DUK_COMPILING_DUKTAPE)
-+/* See: /opt/qnx650/target/qnx6/usr/include/sys/platform.h */
-+#define _XOPEN_SOURCE    600
-+#define _POSIX_C_SOURCE  200112L
-+#endif
-+
-+#undef DUK_F_MSVC_CRT_SECURE
-+#if defined(DUK_F_WINDOWS) && defined(_MSC_VER)
-+/* http://msdn.microsoft.com/en-us/library/8ef0s5kh.aspx
-+ * http://msdn.microsoft.com/en-us/library/wd3wzwts.aspx
-+ * Seem to be available since VS2005.
-+ */
-+#if (_MSC_VER >= 1400)
-+/* VS2005+, secure CRT functions are preferred.  Windows Store applications
-+ * (and probably others) should use these.
-+ */
-+#define DUK_F_MSVC_CRT_SECURE
-+#endif
-+#if (_MSC_VER < 1700)
-+/* VS2012+ has stdint.h, < VS2012 does not (but it's available for download). */
-+#define DUK_F_NO_STDINT_H
-+#endif
-+/* Initial fix: disable secure CRT related warnings when compiling Duktape
-+ * itself (must be defined before including Windows headers).  Don't define
-+ * for user code including duktape.h.
-+ */
-+#if defined(DUK_COMPILING_DUKTAPE) && !defined(_CRT_SECURE_NO_WARNINGS)
-+#define _CRT_SECURE_NO_WARNINGS
-+#endif
-+#endif  /* DUK_F_WINDOWS && _MSC_VER */
-+
-+#if defined(DUK_F_TOS) || defined(DUK_F_BCC)
-+#define DUK_F_NO_STDINT_H
-+#endif
-+
-+/* Workaround for older C++ compilers before including <inttypes.h>,
-+ * see e.g.: https://sourceware.org/bugzilla/show_bug.cgi?id=15366
-+ */
-+#if defined(__cplusplus) && !defined(__STDC_LIMIT_MACROS)
-+#define __STDC_LIMIT_MACROS
-+#endif
-+#if defined(__cplusplus) && !defined(__STDC_CONSTANT_MACROS)
-+#define __STDC_CONSTANT_MACROS
-+#endif
-+
-+#if defined(__APPLE__)
-+/* Mac OSX, iPhone, Darwin */
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <TargetConditionals.h>
-+#include <architecture/byte_order.h>
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#elif defined(DUK_F_OPENBSD)
-+/* http://www.monkey.org/openbsd/archive/ports/0401/msg00089.html */
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <sys/types.h>
-+#include <sys/endian.h>
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#elif defined(DUK_F_BSD)
-+/* other BSD */
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <sys/types.h>
-+#include <sys/endian.h>
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#elif defined(DUK_F_TOS)
-+/* Atari ST TOS */
-+#define DUK_USE_DATE_NOW_TIME
-+#define DUK_USE_DATE_TZO_GMTIME
-+/* no parsing (not an error) */
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <limits.h>
-+#include <time.h>
-+#elif defined(DUK_F_AMIGAOS)
-+#if defined(DUK_F_M68K)
-+/* AmigaOS on M68k */
-+#define DUK_USE_DATE_NOW_TIME
-+#define DUK_USE_DATE_TZO_GMTIME
-+/* no parsing (not an error) */
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <limits.h>
-+#include <time.h>
-+#else
-+#error AmigaOS but not M68K, not supported now
-+#endif
-+#elif defined(DUK_F_WINDOWS)
-+/* Windows 32-bit and 64-bit are currently the same. */
-+/* MSVC does not have sys/param.h */
-+#define DUK_USE_DATE_NOW_WINDOWS
-+#define DUK_USE_DATE_TZO_WINDOWS
-+/* Note: PRS and FMT are intentionally left undefined for now.  This means
-+ * there is no platform specific date parsing/formatting but there is still
-+ * the ISO 8601 standard format.
-+ */
-+#include <windows.h>
-+#include <limits.h>
-+#elif defined(DUK_F_FLASHPLAYER)
-+/* Crossbridge */
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <endian.h>
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#elif defined(DUK_F_QNX)
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <sys/types.h>
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#elif defined(DUK_F_TINSPIRE)
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <sys/types.h>
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#elif defined(DUK_F_LINUX)
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <sys/types.h>
-+#if defined(DUK_F_BCC)
-+/* no endian.h */
-+#else
-+#include <endian.h>
-+#endif  /* DUK_F_BCC */
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#elif defined(__posix)
-+/* POSIX */
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <sys/types.h>
-+#include <endian.h>
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#elif defined(DUK_F_CYGWIN)
-+/* Cygwin -- don't use strptime() for now */
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <sys/types.h>
-+#include <endian.h>
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#else
-+/* Other UNIX, hopefully others */
-+#define DUK_USE_DATE_NOW_GETTIMEOFDAY
-+#define DUK_USE_DATE_TZO_GMTIME_R
-+#define DUK_USE_DATE_PRS_STRPTIME
-+#define DUK_USE_DATE_FMT_STRFTIME
-+#include <sys/types.h>
-+#if defined(DUK_F_BCC)
-+/* no endian.h */
-+#else
-+#include <endian.h>
-+#endif  /* DUK_F_BCC */
-+#include <limits.h>
-+#include <sys/param.h>
-+#include <sys/time.h>
-+#include <time.h>
-+#endif
-+
-+/* Shared includes */
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <string.h>
-+#include <stdarg.h>  /* varargs */
-+#include <setjmp.h>
-+#include <stddef.h>  /* e.g. ptrdiff_t */
-+#if defined(DUK_F_NO_STDINT_H)
-+/* stdint.h not available */
-+#else
-+/* Technically C99 (C++11) but found in many systems.  Note the workaround
-+ * above for some C++ compilers (__STDC_LIMIT_MACROS etc).
-+ */
-+#include <stdint.h>
-+#endif
-+#include <math.h>
-+
-+/*
-+ *  Detection for specific libc variants (like uclibc) and other libc specific
-+ *  features.  Potentially depends on the #includes above.
-+ */
-+
-+#if defined(__UCLIBC__)
-+#define DUK_F_UCLIBC
-+#endif
-+
-+/*
-+ *  Wrapper typedefs and constants for integer types, also sanity check types.
-+ *
-+ *  C99 typedefs are quite good but not always available, and we want to avoid
-+ *  forcibly redefining the C99 typedefs.  So, there are Duktape wrappers for
-+ *  all C99 typedefs and Duktape code should only use these typedefs.  Type
-+ *  detection when C99 is not supported is best effort and may end up detecting
-+ *  some types incorrectly.
-+ *
-+ *  Pointer sizes are a portability problem: pointers to different types may
-+ *  have a different size and function pointers are very difficult to manage
-+ *  portably.
-+ *
-+ *  http://en.wikipedia.org/wiki/C_data_types#Fixed-width_integer_types
-+ *
-+ *  Note: there's an interesting corner case when trying to define minimum
-+ *  signed integer value constants which leads to the current workaround of
-+ *  defining e.g. -0x80000000 as (-0x7fffffffL - 1L).  See doc/code-issues.txt
-+ *  for a longer discussion.
-+ *
-+ *  Note: avoid typecasts and computations in macro integer constants as they
-+ *  can then no longer be used in macro relational expressions (such as
-+ *  #if DUK_SIZE_MAX < 0xffffffffUL).  There is internal code which relies on
-+ *  being able to compare DUK_SIZE_MAX against a limit.
-+ */
-+
-+/* XXX: add feature options to force basic types from outside? */
-+
-+#if !defined(INT_MAX)
-+#error INT_MAX not defined
-+#endif
-+
-+/* Check that architecture is two's complement, standard C allows e.g.
-+ * INT_MIN to be -2**31+1 (instead of -2**31).
-+ */
-+#if defined(INT_MAX) && defined(INT_MIN)
-+#if INT_MAX != -(INT_MIN + 1)
-+#error platform does not seem complement of two
-+#endif
-+#else
-+#error cannot check complement of two
-+#endif
-+
-+/* Pointer size determination based on architecture.
-+ * XXX: unsure about BCC correctness.
-+ */
-+#if defined(DUK_F_X86) || defined(DUK_F_X32) || \
-+    defined(DUK_F_BCC) || \
-+    (defined(__WORDSIZE) && (__WORDSIZE == 32))
-+#define DUK_F_32BIT_PTRS
-+#elif defined(DUK_F_X64) || \
-+      (defined(__WORDSIZE) && (__WORDSIZE == 64))
-+#define DUK_F_64BIT_PTRS
-+#else
-+/* not sure, not needed with C99 anyway */
-+#endif
-+
-+/* Intermediate define for 'have inttypes.h' */
-+#undef DUK_F_HAVE_INTTYPES
-+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
-+    !(defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC))
-+/* vbcc + AmigaOS has C99 but no inttypes.h */
-+#define DUK_F_HAVE_INTTYPES
-+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
-+/* C++11 apparently ratified stdint.h */
-+#define DUK_F_HAVE_INTTYPES
-+#endif
-+
-+/* Basic integer typedefs and limits, preferably from inttypes.h, otherwise
-+ * through automatic detection.
-+ */
-+#if defined(DUK_F_HAVE_INTTYPES)
-+/* C99 or compatible */
-+
-+#define DUK_F_HAVE_64BIT
-+#include <inttypes.h>
-+
-+typedef uint8_t duk_uint8_t;
-+typedef int8_t duk_int8_t;
-+typedef uint16_t duk_uint16_t;
-+typedef int16_t duk_int16_t;
-+typedef uint32_t duk_uint32_t;
-+typedef int32_t duk_int32_t;
-+typedef uint64_t duk_uint64_t;
-+typedef int64_t duk_int64_t;
-+typedef uint_least8_t duk_uint_least8_t;
-+typedef int_least8_t duk_int_least8_t;
-+typedef uint_least16_t duk_uint_least16_t;
-+typedef int_least16_t duk_int_least16_t;
-+typedef uint_least32_t duk_uint_least32_t;
-+typedef int_least32_t duk_int_least32_t;
-+typedef uint_least64_t duk_uint_least64_t;
-+typedef int_least64_t duk_int_least64_t;
-+typedef uint_fast8_t duk_uint_fast8_t;
-+typedef int_fast8_t duk_int_fast8_t;
-+typedef uint_fast16_t duk_uint_fast16_t;
-+typedef int_fast16_t duk_int_fast16_t;
-+typedef uint_fast32_t duk_uint_fast32_t;
-+typedef int_fast32_t duk_int_fast32_t;
-+typedef uint_fast64_t duk_uint_fast64_t;
-+typedef int_fast64_t duk_int_fast64_t;
-+typedef uintptr_t duk_uintptr_t;
-+typedef intptr_t duk_intptr_t;
-+typedef uintmax_t duk_uintmax_t;
-+typedef intmax_t duk_intmax_t;
-+
-+#define DUK_UINT8_MIN         0
-+#define DUK_UINT8_MAX         UINT8_MAX
-+#define DUK_INT8_MIN          INT8_MIN
-+#define DUK_INT8_MAX          INT8_MAX
-+#define DUK_UINT_LEAST8_MIN   0
-+#define DUK_UINT_LEAST8_MAX   UINT_LEAST8_MAX
-+#define DUK_INT_LEAST8_MIN    INT_LEAST8_MIN
-+#define DUK_INT_LEAST8_MAX    INT_LEAST8_MAX
-+#define DUK_UINT_FAST8_MIN    0
-+#define DUK_UINT_FAST8_MAX    UINT_FAST8_MAX
-+#define DUK_INT_FAST8_MIN     INT_FAST8_MIN
-+#define DUK_INT_FAST8_MAX     INT_FAST8_MAX
-+#define DUK_UINT16_MIN        0
-+#define DUK_UINT16_MAX        UINT16_MAX
-+#define DUK_INT16_MIN         INT16_MIN
-+#define DUK_INT16_MAX         INT16_MAX
-+#define DUK_UINT_LEAST16_MIN  0
-+#define DUK_UINT_LEAST16_MAX  UINT_LEAST16_MAX
-+#define DUK_INT_LEAST16_MIN   INT_LEAST16_MIN
-+#define DUK_INT_LEAST16_MAX   INT_LEAST16_MAX
-+#define DUK_UINT_FAST16_MIN   0
-+#define DUK_UINT_FAST16_MAX   UINT_FAST16_MAX
-+#define DUK_INT_FAST16_MIN    INT_FAST16_MIN
-+#define DUK_INT_FAST16_MAX    INT_FAST16_MAX
-+#define DUK_UINT32_MIN        0
-+#define DUK_UINT32_MAX        UINT32_MAX
-+#define DUK_INT32_MIN         INT32_MIN
-+#define DUK_INT32_MAX         INT32_MAX
-+#define DUK_UINT_LEAST32_MIN  0
-+#define DUK_UINT_LEAST32_MAX  UINT_LEAST32_MAX
-+#define DUK_INT_LEAST32_MIN   INT_LEAST32_MIN
-+#define DUK_INT_LEAST32_MAX   INT_LEAST32_MAX
-+#define DUK_UINT_FAST32_MIN   0
-+#define DUK_UINT_FAST32_MAX   UINT_FAST32_MAX
-+#define DUK_INT_FAST32_MIN    INT_FAST32_MIN
-+#define DUK_INT_FAST32_MAX    INT_FAST32_MAX
-+#define DUK_UINT64_MIN        0
-+#define DUK_UINT64_MAX        UINT64_MAX
-+#define DUK_INT64_MIN         INT64_MIN
-+#define DUK_INT64_MAX         INT64_MAX
-+#define DUK_UINT_LEAST64_MIN  0
-+#define DUK_UINT_LEAST64_MAX  UINT_LEAST64_MAX
-+#define DUK_INT_LEAST64_MIN   INT_LEAST64_MIN
-+#define DUK_INT_LEAST64_MAX   INT_LEAST64_MAX
-+#define DUK_UINT_FAST64_MIN   0
-+#define DUK_UINT_FAST64_MAX   UINT_FAST64_MAX
-+#define DUK_INT_FAST64_MIN    INT_FAST64_MIN
-+#define DUK_INT_FAST64_MAX    INT_FAST64_MAX
-+
-+#define DUK_UINTPTR_MIN       0
-+#define DUK_UINTPTR_MAX       UINTPTR_MAX
-+#define DUK_INTPTR_MIN        INTPTR_MIN
-+#define DUK_INTPTR_MAX        INTPTR_MAX
-+
-+#define DUK_UINTMAX_MIN       0
-+#define DUK_UINTMAX_MAX       UINTMAX_MAX
-+#define DUK_INTMAX_MIN        INTMAX_MIN
-+#define DUK_INTMAX_MAX        INTMAX_MAX
-+
-+#define DUK_SIZE_MIN          0
-+#define DUK_SIZE_MAX          SIZE_MAX
-+
-+#else  /* C99 types */
-+
-+/* When C99 types are not available, we use heuristic detection to get
-+ * the basic 8, 16, 32, and (possibly) 64 bit types.  The fast/least
-+ * types are then assumed to be exactly the same for now: these could
-+ * be improved per platform but C99 types are very often now available.
-+ * 64-bit types are not available on all platforms; this is OK at least
-+ * on 32-bit platforms.
-+ *
-+ * This detection code is necessarily a bit hacky and can provide typedefs
-+ * and defines that won't work correctly on some exotic platform.
-+ */
-+
-+#if (defined(CHAR_BIT) && (CHAR_BIT == 8)) || \
-+    (defined(UCHAR_MAX) && (UCHAR_MAX == 255))
-+typedef unsigned char duk_uint8_t;
-+typedef signed char duk_int8_t;
-+#else
-+#error cannot detect 8-bit type
-+#endif
-+
-+#if defined(USHRT_MAX) && (USHRT_MAX == 65535UL)
-+typedef unsigned short duk_uint16_t;
-+typedef signed short duk_int16_t;
-+#elif defined(UINT_MAX) && (UINT_MAX == 65535UL)
-+/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */
-+typedef unsigned int duk_uint16_t;
-+typedef signed int duk_int16_t;
-+#else
-+#error cannot detect 16-bit type
-+#endif
-+
-+#if defined(UINT_MAX) && (UINT_MAX == 4294967295UL)
-+typedef unsigned int duk_uint32_t;
-+typedef signed int duk_int32_t;
-+#elif defined(ULONG_MAX) && (ULONG_MAX == 4294967295UL)
-+/* On some platforms int is 16-bit but long is 32-bit (e.g. PureC) */
-+typedef unsigned long duk_uint32_t;
-+typedef signed long duk_int32_t;
-+#else
-+#error cannot detect 32-bit type
-+#endif
-+
-+/* 64-bit type detection is a bit tricky.
-+ *
-+ * ULLONG_MAX is a standard define.  __LONG_LONG_MAX__ and __ULONG_LONG_MAX__
-+ * are used by at least GCC (even if system headers don't provide ULLONG_MAX).
-+ * Some GCC variants may provide __LONG_LONG_MAX__ but not __ULONG_LONG_MAX__.
-+ *
-+ * ULL / LL constants are rejected / warned about by some compilers, even if
-+ * the compiler has a 64-bit type and the compiler/system headers provide an
-+ * unsupported constant (ULL/LL)!  Try to avoid using ULL / LL constants.
-+ * As a side effect we can only check that e.g. ULONG_MAX is larger than 32
-+ * bits but can't be sure it is exactly 64 bits.  Self tests will catch such
-+ * cases.
-+ */
-+#undef DUK_F_HAVE_64BIT
-+#if !defined(DUK_F_HAVE_64BIT) && defined(ULONG_MAX)
-+#if (ULONG_MAX > 4294967295UL)
-+#define DUK_F_HAVE_64BIT
-+typedef unsigned long duk_uint64_t;
-+typedef signed long duk_int64_t;
-+#endif
-+#endif
-+#if !defined(DUK_F_HAVE_64BIT) && defined(ULLONG_MAX)
-+#if (ULLONG_MAX > 4294967295UL)
-+#define DUK_F_HAVE_64BIT
-+typedef unsigned long long duk_uint64_t;
-+typedef signed long long duk_int64_t;
-+#endif
-+#endif
-+#if !defined(DUK_F_HAVE_64BIT) && defined(__ULONG_LONG_MAX__)
-+#if (__ULONG_LONG_MAX__ > 4294967295UL)
-+#define DUK_F_HAVE_64BIT
-+typedef unsigned long long duk_uint64_t;
-+typedef signed long long duk_int64_t;
-+#endif
-+#endif
-+#if !defined(DUK_F_HAVE_64BIT) && defined(__LONG_LONG_MAX__)
-+#if (__LONG_LONG_MAX__ > 2147483647L)
-+#define DUK_F_HAVE_64BIT
-+typedef unsigned long long duk_uint64_t;
-+typedef signed long long duk_int64_t;
-+#endif
-+#endif
-+#if !defined(DUK_F_HAVE_64BIT) && \
-+    (defined(DUK_F_MINGW) || defined(DUK_F_MSVC))
-+/* Both MinGW and MSVC have a 64-bit type. */
-+#define DUK_F_HAVE_64BIT
-+typedef unsigned long duk_uint64_t;
-+typedef signed long duk_int64_t;
-+#endif
-+#if !defined(DUK_F_HAVE_64BIT)
-+/* cannot detect 64-bit type, not always needed so don't error */
-+#endif
-+
-+typedef duk_uint8_t duk_uint_least8_t;
-+typedef duk_int8_t duk_int_least8_t;
-+typedef duk_uint16_t duk_uint_least16_t;
-+typedef duk_int16_t duk_int_least16_t;
-+typedef duk_uint32_t duk_uint_least32_t;
-+typedef duk_int32_t duk_int_least32_t;
-+typedef duk_uint8_t duk_uint_fast8_t;
-+typedef duk_int8_t duk_int_fast8_t;
-+typedef duk_uint16_t duk_uint_fast16_t;
-+typedef duk_int16_t duk_int_fast16_t;
-+typedef duk_uint32_t duk_uint_fast32_t;
-+typedef duk_int32_t duk_int_fast32_t;
-+#if defined(DUK_F_HAVE_64BIT)
-+typedef duk_uint64_t duk_uint_least64_t;
-+typedef duk_int64_t duk_int_least64_t;
-+typedef duk_uint64_t duk_uint_fast64_t;
-+typedef duk_int64_t duk_int_fast64_t;
-+#endif
-+#if defined(DUK_F_HAVE_64BIT)
-+typedef duk_uint64_t duk_uintmax_t;
-+typedef duk_int64_t duk_intmax_t;
-+#else
-+typedef duk_uint32_t duk_uintmax_t;
-+typedef duk_int32_t duk_intmax_t;
-+#endif
-+
-+/* Note: the funny looking computations for signed minimum 16-bit, 32-bit, and
-+ * 64-bit values are intentional as the obvious forms (e.g. -0x80000000L) are
-+ * -not- portable.  See code-issues.txt for a detailed discussion.
-+ */
-+#define DUK_UINT8_MIN         0UL
-+#define DUK_UINT8_MAX         0xffUL
-+#define DUK_INT8_MIN          (-0x80L)
-+#define DUK_INT8_MAX          0x7fL
-+#define DUK_UINT_LEAST8_MIN   0UL
-+#define DUK_UINT_LEAST8_MAX   0xffUL
-+#define DUK_INT_LEAST8_MIN    (-0x80L)
-+#define DUK_INT_LEAST8_MAX    0x7fL
-+#define DUK_UINT_FAST8_MIN    0UL
-+#define DUK_UINT_FAST8_MAX    0xffUL
-+#define DUK_INT_FAST8_MIN     (-0x80L)
-+#define DUK_INT_FAST8_MAX     0x7fL
-+#define DUK_UINT16_MIN        0UL
-+#define DUK_UINT16_MAX        0xffffUL
-+#define DUK_INT16_MIN         (-0x7fffL - 1L)
-+#define DUK_INT16_MAX         0x7fffL
-+#define DUK_UINT_LEAST16_MIN  0UL
-+#define DUK_UINT_LEAST16_MAX  0xffffUL
-+#define DUK_INT_LEAST16_MIN   (-0x7fffL - 1L)
-+#define DUK_INT_LEAST16_MAX   0x7fffL
-+#define DUK_UINT_FAST16_MIN   0UL
-+#define DUK_UINT_FAST16_MAX   0xffffUL
-+#define DUK_INT_FAST16_MIN    (-0x7fffL - 1L)
-+#define DUK_INT_FAST16_MAX    0x7fffL
-+#define DUK_UINT32_MIN        0UL
-+#define DUK_UINT32_MAX        0xffffffffUL
-+#define DUK_INT32_MIN         (-0x7fffffffL - 1L)
-+#define DUK_INT32_MAX         0x7fffffffL
-+#define DUK_UINT_LEAST32_MIN  0UL
-+#define DUK_UINT_LEAST32_MAX  0xffffffffUL
-+#define DUK_INT_LEAST32_MIN   (-0x7fffffffL - 1L)
-+#define DUK_INT_LEAST32_MAX   0x7fffffffL
-+#define DUK_UINT_FAST32_MIN   0UL
-+#define DUK_UINT_FAST32_MAX   0xffffffffUL
-+#define DUK_INT_FAST32_MIN    (-0x7fffffffL - 1L)
-+#define DUK_INT_FAST32_MAX    0x7fffffffL
-+
-+/* 64-bit constants.  Since LL / ULL constants are not always available,
-+ * use computed values.  These values can't be used in preprocessor
-+ * comparisons; flag them as such.
-+ */
-+#if defined(DUK_F_HAVE_64BIT)
-+#define DUK_UINT64_MIN        ((duk_uint64_t) 0)
-+#define DUK_UINT64_MAX        ((duk_uint64_t) -1)
-+#define DUK_INT64_MIN         ((duk_int64_t) (~(DUK_UINT64_MAX >> 1)))
-+#define DUK_INT64_MAX         ((duk_int64_t) (DUK_UINT64_MAX >> 1))
-+#define DUK_UINT_LEAST64_MIN  DUK_UINT64_MIN
-+#define DUK_UINT_LEAST64_MAX  DUK_UINT64_MAX
-+#define DUK_INT_LEAST64_MIN   DUK_INT64_MIN
-+#define DUK_INT_LEAST64_MAX   DUK_INT64_MAX
-+#define DUK_UINT_FAST64_MIN   DUK_UINT64_MIN
-+#define DUK_UINT_FAST64_MAX   DUK_UINT64_MAX
-+#define DUK_INT_FAST64_MIN    DUK_INT64_MIN
-+#define DUK_INT_FAST64_MAX    DUK_INT64_MAX
-+#define DUK_UINT64_MIN_COMPUTED
-+#define DUK_UINT64_MAX_COMPUTED
-+#define DUK_INT64_MIN_COMPUTED
-+#define DUK_INT64_MAX_COMPUTED
-+#define DUK_UINT_LEAST64_MIN_COMPUTED
-+#define DUK_UINT_LEAST64_MAX_COMPUTED
-+#define DUK_INT_LEAST64_MIN_COMPUTED
-+#define DUK_INT_LEAST64_MAX_COMPUTED
-+#define DUK_UINT_FAST64_MIN_COMPUTED
-+#define DUK_UINT_FAST64_MAX_COMPUTED
-+#define DUK_INT_FAST64_MIN_COMPUTED
-+#define DUK_INT_FAST64_MAX_COMPUTED
-+#endif
-+
-+#if defined(DUK_F_HAVE_64BIT)
-+#define DUK_UINTMAX_MIN       DUK_UINT64_MIN
-+#define DUK_UINTMAX_MAX       DUK_UINT64_MAX
-+#define DUK_INTMAX_MIN        DUK_INT64_MIN
-+#define DUK_INTMAX_MAX        DUK_INT64_MAX
-+#define DUK_UINTMAX_MIN_COMPUTED
-+#define DUK_UINTMAX_MAX_COMPUTED
-+#define DUK_INTMAX_MIN_COMPUTED
-+#define DUK_INTMAX_MAX_COMPUTED
-+#else
-+#define DUK_UINTMAX_MIN       0UL
-+#define DUK_UINTMAX_MAX       0xffffffffUL
-+#define DUK_INTMAX_MIN        (-0x7fffffffL - 1L)
-+#define DUK_INTMAX_MAX        0x7fffffffL
-+#endif
-+
-+/* This detection is not very reliable. */
-+#if defined(DUK_F_32BIT_PTRS)
-+typedef duk_int32_t duk_intptr_t;
-+typedef duk_uint32_t duk_uintptr_t;
-+#define DUK_UINTPTR_MIN       DUK_UINT32_MIN
-+#define DUK_UINTPTR_MAX       DUK_UINT32_MAX
-+#define DUK_INTPTR_MIN        DUK_INT32_MIN
-+#define DUK_INTPTR_MAX        DUK_INT32_MAX
-+#elif defined(DUK_F_64BIT_PTRS) && defined(DUK_F_HAVE_64BIT)
-+typedef duk_int64_t duk_intptr_t;
-+typedef duk_uint64_t duk_uintptr_t;
-+#define DUK_UINTPTR_MIN       DUK_UINT64_MIN
-+#define DUK_UINTPTR_MAX       DUK_UINT64_MAX
-+#define DUK_INTPTR_MIN        DUK_INT64_MIN
-+#define DUK_INTPTR_MAX        DUK_INT64_MAX
-+#define DUK_UINTPTR_MIN_COMPUTED
-+#define DUK_UINTPTR_MAX_COMPUTED
-+#define DUK_INTPTR_MIN_COMPUTED
-+#define DUK_INTPTR_MAX_COMPUTED
-+#else
-+#error cannot determine intptr type
-+#endif
-+
-+/* SIZE_MAX may be missing so use an approximate value for it. */
-+#undef DUK_SIZE_MAX_COMPUTED
-+#if !defined(SIZE_MAX)
-+#define DUK_SIZE_MAX_COMPUTED
-+#define SIZE_MAX              ((size_t) (-1))
-+#endif
-+#define DUK_SIZE_MIN          0
-+#define DUK_SIZE_MAX          SIZE_MAX
-+
-+#endif  /* C99 types */
-+
-+/* A few types are assumed to always exist. */
-+typedef size_t duk_size_t;
-+typedef ptrdiff_t duk_ptrdiff_t;
-+
-+/* The best type for an "all around int" in Duktape internals is "at least
-+ * 32 bit signed integer" which is most convenient.  Same for unsigned type.
-+ * Prefer 'int' when large enough, as it is almost always a convenient type.
-+ */
-+#if defined(UINT_MAX) && (UINT_MAX >= 0xffffffffUL)
-+typedef int duk_int_t;
-+typedef unsigned int duk_uint_t;
-+#define DUK_INT_MIN           INT_MIN
-+#define DUK_INT_MAX           INT_MAX
-+#define DUK_UINT_MIN          0
-+#define DUK_UINT_MAX          UINT_MAX
-+#else
-+typedef duk_int_fast32_t duk_int_t;
-+typedef duk_uint_fast32_t duk_uint_t;
-+#define DUK_INT_MIN           DUK_INT_FAST32_MIN
-+#define DUK_INT_MAX           DUK_INT_FAST32_MAX
-+#define DUK_UINT_MIN          DUK_UINT_FAST32_MIN
-+#define DUK_UINT_MAX          DUK_UINT_FAST32_MAX
-+#endif
-+
-+/* Same as 'duk_int_t' but guaranteed to be a 'fast' variant if this
-+ * distinction matters for the CPU.  These types are used mainly in the
-+ * executor where it might really matter.
-+ */
-+typedef duk_int_fast32_t duk_int_fast_t;
-+typedef duk_uint_fast32_t duk_uint_fast_t;
-+#define DUK_INT_FAST_MIN      DUK_INT_FAST32_MIN
-+#define DUK_INT_FAST_MAX      DUK_INT_FAST32_MAX
-+#define DUK_UINT_FAST_MIN     DUK_UINT_FAST32_MIN
-+#define DUK_UINT_FAST_MAX     DUK_UINT_FAST32_MAX
-+
-+/* Small integers (16 bits or more) can fall back to the 'int' type, but
-+ * have a typedef so they are marked "small" explicitly.
-+ */
-+typedef int duk_small_int_t;
-+typedef unsigned int duk_small_uint_t;
-+#define DUK_SMALL_INT_MIN     INT_MIN
-+#define DUK_SMALL_INT_MAX     INT_MAX
-+#define DUK_SMALL_UINT_MIN    0
-+#define DUK_SMALL_UINT_MAX    UINT_MAX
-+
-+/* Fast variants of small integers, again for really fast paths like the
-+ * executor.
-+ */
-+typedef duk_int_fast16_t duk_small_int_fast_t;
-+typedef duk_uint_fast16_t duk_small_uint_fast_t;
-+#define DUK_SMALL_INT_FAST_MIN    DUK_INT_FAST16_MIN
-+#define DUK_SMALL_INT_FAST_MAX    DUK_INT_FAST16_MAX
-+#define DUK_SMALL_UINT_FAST_MIN   DUK_UINT_FAST16_MIN
-+#define DUK_SMALL_UINT_FAST_MAX   DUK_UINT_FAST16_MAX
-+
-+/* Boolean values are represented with the platform 'int'. */
-+typedef duk_small_int_t duk_bool_t;
-+#define DUK_BOOL_MIN              DUK_SMALL_INT_MIN
-+#define DUK_BOOL_MAX              DUK_SMALL_INT_MAX
-+
-+/* Index values must have at least 32-bit signed range. */
-+typedef duk_int_t duk_idx_t;
-+#define DUK_IDX_MIN               DUK_INT_MIN
-+#define DUK_IDX_MAX               DUK_INT_MAX
-+
-+/* Array index values, could be exact 32 bits.
-+ * Currently no need for signed duk_arridx_t.
-+ */
-+typedef duk_uint_t duk_uarridx_t;
-+#define DUK_UARRIDX_MIN           DUK_UINT_MIN
-+#define DUK_UARRIDX_MAX           DUK_UINT_MAX
-+
-+/* Duktape/C function return value, platform int is enough for now to
-+ * represent 0, 1, or negative error code.  Must be compatible with
-+ * assigning truth values (e.g. duk_ret_t rc = (foo == bar);).
-+ */
-+typedef duk_small_int_t duk_ret_t;
-+#define DUK_RET_MIN               DUK_SMALL_INT_MIN
-+#define DUK_RET_MAX               DUK_SMALL_INT_MAX
-+
-+/* Error codes are represented with platform int.  High bits are used
-+ * for flags and such, so 32 bits are needed.
-+ */
-+typedef duk_int_t duk_errcode_t;
-+#define DUK_ERRCODE_MIN           DUK_INT_MIN
-+#define DUK_ERRCODE_MAX           DUK_INT_MAX
-+
-+/* Codepoint type.  Must be 32 bits or more because it is used also for
-+ * internal codepoints.  The type is signed because negative codepoints
-+ * are used as internal markers (e.g. to mark EOF or missing argument).
-+ * (X)UTF-8/CESU-8 encode/decode take and return an unsigned variant to
-+ * ensure duk_uint32_t casts back and forth nicely.  Almost everything
-+ * else uses the signed one.
-+ */
-+typedef duk_int_t duk_codepoint_t;
-+typedef duk_uint_t duk_ucodepoint_t;
-+#define DUK_CODEPOINT_MIN         DUK_INT_MIN
-+#define DUK_CODEPOINT_MAX         DUK_INT_MAX
-+#define DUK_UCODEPOINT_MIN        DUK_UINT_MIN
-+#define DUK_UCODEPOINT_MAX        DUK_UINT_MAX
-+
-+/* IEEE double typedef. */
-+typedef double duk_double_t;
-+
-+/* We're generally assuming that we're working on a platform with a 32-bit
-+ * address space.  If DUK_SIZE_MAX is a typecast value (which is necessary
-+ * if SIZE_MAX is missing), the check must be avoided because the
-+ * preprocessor can't do a comparison.
-+ */
-+#if !defined(DUK_SIZE_MAX)
-+#error DUK_SIZE_MAX is undefined, probably missing SIZE_MAX
-+#elif !defined(DUK_SIZE_MAX_COMPUTED)
-+#if DUK_SIZE_MAX < 0xffffffffUL
-+/* On some systems SIZE_MAX can be smaller than max unsigned 32-bit value
-+ * which seems incorrect if size_t is (at least) an unsigned 32-bit type.
-+ * However, it doesn't seem useful to error out compilation if this is the
-+ * case.
-+ */
-+#endif
-+#endif
-+
-+/* Convenience define: 32-bit pointers.  32-bit platforms are an important
-+ * footprint optimization target, and this define allows e.g. struct sizes
-+ * to be organized for compactness.
-+ */
-+
-+#undef DUK_USE_32BIT_PTRS
-+#if defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED)
-+#if DUK_UINTPTR_MAX <= 0xffffffffUL
-+#define DUK_USE_32BIT_PTRS
-+#endif
-+#endif
-+
-+/*
-+ *  Check whether we should use 64-bit integers
-+ */
-+
-+/* Quite incomplete now.  Use 64-bit types if detected (C99 or other detection)
-+ * unless they are known to be unreliable.  For instance, 64-bit types are
-+ * available on VBCC but seem to misbehave.
-+ */
-+#if defined(DUK_F_HAVE_64BIT) && !defined(DUK_F_VBCC)
-+#define DUK_USE_64BIT_OPS
-+#else
-+#undef DUK_USE_64BIT_OPS
-+#endif
-+
-+/*
-+ *  Alignment requirement and support for unaligned accesses
-+ *
-+ *  Assume unaligned accesses are not supported unless specifically allowed
-+ *  in the target platform.  Some platforms may support unaligned accesses
-+ *  but alignment to 4 or 8 may still be desirable.
-+ */
-+
-+#undef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE
-+#undef DUK_USE_ALIGN_4
-+#undef DUK_USE_ALIGN_8
-+
-+#if defined(DUK_F_EMSCRIPTEN)
-+/* Required on at least some targets, so use whenever Emscripten used,
-+ * regardless of compilation target.
-+ */
-+#define DUK_USE_ALIGN_8
-+#elif defined(DUK_F_ARM)
-+#define DUK_USE_ALIGN_4
-+#elif defined(DUK_F_MIPS32)
-+/* Based on 'make checkalign' there are no alignment requirements on
-+ * Linux MIPS except for doubles, which need align by 4.  Alignment
-+ * requirements vary based on target though.
-+ */
-+#define DUK_USE_ALIGN_4
-+#elif defined(DUK_F_MIPS64)
-+/* Good default is a bit arbitrary because alignment requirements
-+ * depend on target.  See https://github.com/svaarala/duktape/issues/102.
-+ */
-+#define DUK_USE_ALIGN_8
-+#elif defined(DUK_F_SUPERH)
-+/* Based on 'make checkalign' there are no alignment requirements on
-+ * Linux SH4, but align by 4 is probably a good basic default.
-+ */
-+#define DUK_USE_ALIGN_4
-+#elif defined(DUK_F_X86) || defined(DUK_F_X32) || defined(DUK_F_X64) || \
-+      defined(DUK_F_BCC)
-+/* XXX: This is technically not guaranteed because it's possible to configure
-+ * an x86 to require aligned accesses with Alignment Check (AC) flag.
-+ */
-+#define DUK_USE_UNALIGNED_ACCESSES_POSSIBLE
-+#else
-+/* Unknown, use safe default */
-+#define DUK_USE_ALIGN_8
-+#endif
-+
-+/* User forced alignment to 4 or 8. */
-+#if defined(DUK_OPT_FORCE_ALIGN)
-+#undef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE
-+#undef DUK_USE_ALIGN_4
-+#undef DUK_USE_ALIGN_8
-+#if (DUK_OPT_FORCE_ALIGN == 4)
-+#define DUK_USE_ALIGN_4
-+#elif (DUK_OPT_FORCE_ALIGN == 8)
-+#define DUK_USE_ALIGN_8
-+#else
-+#error invalid DUK_OPT_FORCE_ALIGN value
-+#endif
-+#endif
-+
-+/* Compiler specific hackery needed to force struct size to match aligment,
-+ * see e.g. duk_hbuffer.h.
-+ *
-+ * http://stackoverflow.com/questions/11130109/c-struct-size-alignment
-+ * http://stackoverflow.com/questions/10951039/specifying-64-bit-alignment
-+ */
-+#if defined(DUK_F_MSVC)
-+#define DUK_USE_PACK_MSVC_PRAGMA
-+#elif defined(DUK_F_GCC)
-+#define DUK_USE_PACK_GCC_ATTR
-+#elif defined(DUK_F_CLANG)
-+#define DUK_USE_PACK_CLANG_ATTR
-+#else
-+#define DUK_USE_PACK_DUMMY_MEMBER
-+#endif
-+
-+#ifdef DUK_USE_UNALIGNED_ACCESSES_POSSIBLE
-+#define DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS
-+#else
-+#undef DUK_USE_HASHBYTES_UNALIGNED_U32_ACCESS
-+#endif
-+
-+/* Object property allocation layout has implications for memory and code
-+ * footprint and generated code size/speed.  The best layout also depends
-+ * on whether the platform has alignment requirements or benefits from
-+ * having mostly aligned accesses.
-+ */
-+#undef DUK_USE_HOBJECT_LAYOUT_1
-+#undef DUK_USE_HOBJECT_LAYOUT_2
-+#undef DUK_USE_HOBJECT_LAYOUT_3
-+#if defined(DUK_USE_UNALIGNED_ACCESSES_POSSIBLE) && \
-+    !defined(DUK_USE_ALIGN_4) && !defined(DUK_USE_ALIGN_8)
-+/* On platforms without any alignment issues, layout 1 is preferable
-+ * because it compiles to slightly less code and provides direct access
-+ * to property keys.
-+ */
-+#define DUK_USE_HOBJECT_LAYOUT_1
-+#else
-+/* On other platforms use layout 2, which requires some padding but
-+ * is a bit more natural than layout 3 in ordering the entries.  Layout
-+ * 3 is currently not used.
-+ */
-+#define DUK_USE_HOBJECT_LAYOUT_2
-+#endif
-+
-+/*
-+ *  Byte order and double memory layout detection
-+ *
-+ *  Endianness detection is a major portability hassle because the macros
-+ *  and headers are not standardized.  There's even variance across UNIX
-+ *  platforms.  Even with "standard" headers, details like underscore count
-+ *  varies between platforms, e.g. both __BYTE_ORDER and _BYTE_ORDER are used
-+ *  (Crossbridge has a single underscore, for instance).
-+ *
-+ *  The checks below are structured with this in mind: several approaches are
-+ *  used, and at the end we check if any of them worked.  This allows generic
-+ *  approaches to be tried first, and platform/compiler specific hacks tried
-+ *  last.  As a last resort, the user can force a specific endianness, as it's
-+ *  not likely that automatic detection will work on the most exotic platforms.
-+ *
-+ *  Duktape supports little and big endian machines.  There's also support
-+ *  for a hybrid used by some ARM machines where integers are little endian
-+ *  but IEEE double values use a mixed order (12345678 -> 43218765).  This
-+ *  byte order for doubles is referred to as "mixed endian".
-+ */
-+
-+#undef DUK_F_BYTEORDER
-+#undef DUK_USE_BYTEORDER_FORCED
-+
-+/* DUK_F_BYTEORDER is set as an intermediate value when detection
-+ * succeeds, to one of:
-+ *   1 = little endian
-+ *   2 = mixed (arm hybrid) endian
-+ *   3 = big endian
-+ */
-+
-+/* For custom platforms allow user to define byteorder explicitly.
-+ * Since endianness headers are not standardized, this is a useful
-+ * workaround for custom platforms for which endianness detection
-+ * is not directly supported.  Perhaps custom hardware is used and
-+ * user cannot submit upstream patches.
-+ */
-+#if defined(DUK_OPT_FORCE_BYTEORDER)
-+#if (DUK_OPT_FORCE_BYTEORDER == 1)
-+#define DUK_F_BYTEORDER 1
-+#elif (DUK_OPT_FORCE_BYTEORDER == 2)
-+#define DUK_F_BYTEORDER 2
-+#elif (DUK_OPT_FORCE_BYTEORDER == 3)
-+#define DUK_F_BYTEORDER 3
-+#else
-+#error invalid DUK_OPT_FORCE_BYTEORDER value
-+#endif
-+#define DUK_USE_BYTEORDER_FORCED
-+#endif  /* DUK_OPT_FORCE_BYTEORDER */
-+
-+/* More or less standard endianness predefines provided by header files.
-+ * The ARM hybrid case is detected by assuming that __FLOAT_WORD_ORDER
-+ * will be big endian, see: http://lists.mysql.com/internals/443.
-+ */
-+#if !defined(DUK_F_BYTEORDER)
-+#if defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN) || \
-+    defined(_BYTE_ORDER) && defined(_LITTLE_ENDIAN) && (_BYTE_ORDER == _LITTLE_ENDIAN) || \
-+    defined(__LITTLE_ENDIAN__)
-+/* Integer little endian */
-+#if defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) || \
-+    defined(_FLOAT_WORD_ORDER) && defined(_LITTLE_ENDIAN) && (_FLOAT_WORD_ORDER == _LITTLE_ENDIAN)
-+#define DUK_F_BYTEORDER 1
-+#elif defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \
-+      defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN)
-+#define DUK_F_BYTEORDER 2
-+#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER)
-+/* Float word order not known, assume not a hybrid. */
-+#define DUK_F_BYTEORDER 1
-+#else
-+/* byte order is little endian but cannot determine IEEE double word order */
-+#endif  /* float word order */
-+#elif defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN) || \
-+      defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && (_BYTE_ORDER == _BIG_ENDIAN) || \
-+      defined(__BIG_ENDIAN__)
-+/* Integer big endian */
-+#if defined(__FLOAT_WORD_ORDER) && defined(__BIG_ENDIAN) && (__FLOAT_WORD_ORDER == __BIG_ENDIAN) || \
-+    defined(_FLOAT_WORD_ORDER) && defined(_BIG_ENDIAN) && (_FLOAT_WORD_ORDER == _BIG_ENDIAN)
-+#define DUK_F_BYTEORDER 3
-+#elif !defined(__FLOAT_WORD_ORDER) && !defined(_FLOAT_WORD_ORDER)
-+/* Float word order not known, assume not a hybrid. */
-+#define DUK_F_BYTEORDER 3
-+#else
-+/* byte order is big endian but cannot determine IEEE double word order */
-+#endif  /* float word order */
-+#else
-+/* cannot determine byte order */
-+#endif  /* integer byte order */
-+#endif  /* !defined(DUK_F_BYTEORDER) */
-+
-+/* GCC and Clang provide endianness defines as built-in predefines, with
-+ * leading and trailing double underscores (e.g. __BYTE_ORDER__).  See
-+ * output of "make gccpredefs" and "make clangpredefs".  Clang doesn't
-+ * seem to provide __FLOAT_WORD_ORDER__.
-+ * http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
-+ */
-+#if !defined(DUK_F_BYTEORDER) && defined(__BYTE_ORDER__)
-+#if defined(__ORDER_LITTLE_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-+/* Integer little endian */
-+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
-+    (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-+#define DUK_F_BYTEORDER 1
-+#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
-+      (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
-+#define DUK_F_BYTEORDER 2
-+#elif !defined(__FLOAT_WORD_ORDER__)
-+/* Float word order not known, assume not a hybrid. */
-+#define DUK_F_BYTEORDER 1
-+#else
-+/* byte order is little endian but cannot determine IEEE double word order */
-+#endif  /* float word order */
-+#elif defined(__ORDER_BIG_ENDIAN__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-+/* Integer big endian */
-+#if defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
-+    (__FLOAT_WORD_ORDER__ == __ORDER_BIG_ENDIAN__)
-+#define DUK_F_BYTEORDER 3
-+#elif !defined(__FLOAT_WORD_ORDER__)
-+/* Float word order not known, assume not a hybrid. */
-+#define DUK_F_BYTEORDER 3
-+#else
-+/* byte order is big endian but cannot determine IEEE double word order */
-+#endif  /* float word order */
-+#else
-+/* cannot determine byte order; __ORDER_PDP_ENDIAN__ is related to 32-bit
-+ * integer ordering and is not relevant
-+ */
-+#endif  /* integer byte order */
-+#endif  /* !defined(DUK_F_BYTEORDER) && defined(__BYTE_ORDER__) */
-+
-+/* Atari ST TOS */
-+#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_TOS)
-+#define DUK_F_BYTEORDER 3
-+#endif
-+
-+/* AmigaOS on M68k */
-+#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_AMIGAOS)
-+#if defined(DUK_F_M68K)
-+#define DUK_F_BYTEORDER 3
-+#endif
-+#endif
-+
-+/* On Windows, assume we're little endian.  Even Itanium which has a
-+ * configurable endianness runs little endian in Windows.
-+ */
-+#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_WINDOWS)
-+/* XXX: verify that Windows on ARM is little endian for floating point
-+ * values too.
-+ */
-+#define DUK_F_BYTEORDER 1
-+#endif  /* Windows */
-+
-+/* Crossbridge should work with the standard byteorder #ifdefs.  It doesn't
-+ * provide _FLOAT_WORD_ORDER but the standard approach now covers that case
-+ * too.  This has been left here just in case.
-+ */
-+#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_FLASHPLAYER)
-+#define DUK_F_BYTEORDER 1
-+#endif
-+
-+/* QNX gcc cross compiler seems to define e.g. __LITTLEENDIAN__ or __BIGENDIAN__:
-+ *  $ /opt/qnx650/host/linux/x86/usr/bin/i486-pc-nto-qnx6.5.0-gcc -dM -E - </dev/null | grep -ni endian
-+ *  67:#define __LITTLEENDIAN__ 1
-+ *  $ /opt/qnx650/host/linux/x86/usr/bin/mips-unknown-nto-qnx6.5.0-gcc -dM -E - </dev/null | grep -ni endian
-+ *  81:#define __BIGENDIAN__ 1
-+ *  $ /opt/qnx650/host/linux/x86/usr/bin/arm-unknown-nto-qnx6.5.0-gcc -dM -E - </dev/null | grep -ni endian
-+ *  70:#define __LITTLEENDIAN__ 1
-+ */
-+#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_QNX)
-+/* XXX: ARM hybrid? */
-+#if defined(__LITTLEENDIAN__)
-+#define DUK_F_BYTEORDER 1
-+#elif defined(__BIGENDIAN__)
-+#define DUK_F_BYTEORDER 3
-+#endif
-+#endif
-+
-+/* Bruce's C Compiler (BCC), assume we're on x86. */
-+#if !defined(DUK_F_BYTEORDER) && defined(DUK_F_BCC)
-+#define DUK_F_BYTEORDER 1
-+#endif
-+
-+/* Check whether or not byte order detection worked based on the intermediate
-+ * define, and define final values.  If detection failed, #error out.
-+ */
-+#if defined(DUK_F_BYTEORDER)
-+#if (DUK_F_BYTEORDER == 1)
-+#define DUK_USE_INTEGER_LE
-+#define DUK_USE_DOUBLE_LE
-+#elif (DUK_F_BYTEORDER == 2)
-+#define DUK_USE_INTEGER_LE  /* integer endianness is little on purpose */
-+#define DUK_USE_DOUBLE_ME
-+#elif (DUK_F_BYTEORDER == 3)
-+#define DUK_USE_INTEGER_BE
-+#define DUK_USE_DOUBLE_BE
-+#else
-+#error unsupported: byte order detection failed (internal error, should not happen)
-+#endif  /* byte order */
-+#else
-+#error unsupported: byte order detection failed
-+#endif  /* defined(DUK_F_BYTEORDER) */
-+
-+/*
-+ *  Check whether or not a packed duk_tval representation is possible.
-+ *  What's basically required is that pointers are 32-bit values
-+ *  (sizeof(void *) == 4).  Best effort check, not always accurate.
-+ *  If guess goes wrong, crashes may result; self tests also verify
-+ *  the guess.
-+ */
-+
-+#undef DUK_USE_PACKED_TVAL_POSSIBLE
-+
-+/* Strict C99 case: DUK_UINTPTR_MAX (= UINTPTR_MAX) should be very reliable */
-+#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_HAVE_INTTYPES) && defined(DUK_UINTPTR_MAX)
-+#if (DUK_UINTPTR_MAX <= 0xffffffffUL)
-+#define DUK_USE_PACKED_TVAL_POSSIBLE
-+#endif
-+#endif
-+
-+/* Non-C99 case, still relying on DUK_UINTPTR_MAX, as long as it is not a computed value */
-+#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_UINTPTR_MAX) && !defined(DUK_UINTPTR_MAX_COMPUTED)
-+#if (DUK_UINTPTR_MAX <= 0xffffffffUL)
-+#define DUK_USE_PACKED_TVAL_POSSIBLE
-+#endif
-+#endif
-+
-+/* DUK_SIZE_MAX (= SIZE_MAX) is often reliable */
-+#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_SIZE_MAX) && !defined(DUK_SIZE_MAX_COMPUTED)
-+#if DUK_SIZE_MAX <= 0xffffffffUL
-+#define DUK_USE_PACKED_TVAL_POSSIBLE
-+#endif
-+#endif
-+
-+/* M68K: packed always possible */
-+#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_M68K)
-+#define DUK_USE_PACKED_TVAL_POSSIBLE
-+#endif
-+
-+/* With Emscripten, force unpacked duk_tval just to be safe, as it seems to
-+ * break at least on Firefox (probably IEEE double arithmetic is not 100%
-+ * supported, especially for NaNs).
-+ */
-+#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_EMSCRIPTEN)
-+#undef DUK_USE_PACKED_TVAL_POSSIBLE
-+#endif
-+
-+/* Microsoft Visual Studio 2010 on x64 fails the above rules and tries to
-+ * use a packed type.  Force unpacked on x64 in general.
-+ */
-+#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) && defined(DUK_F_X64)
-+#undef DUK_USE_PACKED_TVAL_POSSIBLE
-+#endif
-+
-+/* GCC/clang inaccurate math would break compliance and probably duk_tval,
-+ * so refuse to compile.  Relax this if -ffast-math is tested to work.
-+ */
-+#if defined(__FAST_MATH__)
-+#error __FAST_MATH__ defined, refusing to compile
-+#endif
-+
-+/*
-+ *  Detection of double constants and math related functions.  Availability
-+ *  of constants and math functions is a significant porting concern.
-+ *
-+ *  INFINITY/HUGE_VAL is problematic on GCC-3.3: it causes an overflow warning
-+ *  and there is no pragma in GCC-3.3 to disable it.  Using __builtin_inf()
-+ *  avoids this problem for some reason.
-+ */
-+
-+#define DUK_DOUBLE_2TO32     4294967296.0
-+#define DUK_DOUBLE_2TO31     2147483648.0
-+
-+#undef DUK_USE_COMPUTED_INFINITY
-+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION < 40600)
-+/* GCC older than 4.6: avoid overflow warnings related to using INFINITY */
-+#define DUK_DOUBLE_INFINITY  (__builtin_inf())
-+#elif defined(INFINITY)
-+#define DUK_DOUBLE_INFINITY  ((double) INFINITY)
-+#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC)
-+#define DUK_DOUBLE_INFINITY  (1.0 / 0.0)
-+#else
-+/* In VBCC (1.0 / 0.0) results in a warning and 0.0 instead of infinity.
-+ * Use a computed infinity (initialized when a heap is created at the
-+ * latest).
-+ */
-+extern double duk_computed_infinity;
-+#define DUK_USE_COMPUTED_INFINITY
-+#define DUK_DOUBLE_INFINITY  duk_computed_infinity
-+#endif
-+
-+#undef DUK_USE_COMPUTED_NAN
-+#if defined(NAN)
-+#define DUK_DOUBLE_NAN       NAN
-+#elif !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC) && !defined(DUK_F_BCC)
-+#define DUK_DOUBLE_NAN       (0.0 / 0.0)
-+#else
-+/* In VBCC (0.0 / 0.0) results in a warning and 0.0 instead of NaN.
-+ * In MSVC (VS2010 Express) (0.0 / 0.0) results in a compile error.
-+ * Use a computed NaN (initialized when a heap is created at the
-+ * latest).
-+ */
-+extern double duk_computed_nan;
-+#define DUK_USE_COMPUTED_NAN
-+#define DUK_DOUBLE_NAN       duk_computed_nan
-+#endif
-+
-+/* Many platforms are missing fpclassify() and friends, so use replacements
-+ * if necessary.  The replacement constants (FP_NAN etc) can be anything but
-+ * match Linux constants now.
-+ */
-+#undef DUK_USE_REPL_FPCLASSIFY
-+#undef DUK_USE_REPL_SIGNBIT
-+#undef DUK_USE_REPL_ISFINITE
-+#undef DUK_USE_REPL_ISNAN
-+#undef DUK_USE_REPL_ISINF
-+
-+/* Complex condition broken into separate parts. */
-+#undef DUK_F_USE_REPL_ALL
-+#if !(defined(FP_NAN) && defined(FP_INFINITE) && defined(FP_ZERO) && \
-+      defined(FP_SUBNORMAL) && defined(FP_NORMAL))
-+/* Missing some obvious constants. */
-+#define DUK_F_USE_REPL_ALL
-+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)
-+/* VBCC is missing the built-ins even in C99 mode (perhaps a header issue) */
-+#define DUK_F_USE_REPL_ALL
-+#elif defined(DUK_F_FREEBSD) && defined(DUK_F_CLANG)
-+/* Placeholder fix for (detection is wider than necessary):
-+ * http://llvm.org/bugs/show_bug.cgi?id=17788
-+ */
-+#define DUK_F_USE_REPL_ALL
-+#elif defined(DUK_F_UCLIBC)
-+/* At least some uclibc versions have broken floating point math.  For
-+ * example, fpclassify() can incorrectly classify certain NaN formats.
-+ * To be safe, use replacements.
-+ */
-+#define DUK_F_USE_REPL_ALL
-+#endif
-+
-+#if defined(DUK_F_USE_REPL_ALL)
-+#define DUK_USE_REPL_FPCLASSIFY
-+#define DUK_USE_REPL_SIGNBIT
-+#define DUK_USE_REPL_ISFINITE
-+#define DUK_USE_REPL_ISNAN
-+#define DUK_USE_REPL_ISINF
-+#define DUK_FPCLASSIFY       duk_repl_fpclassify
-+#define DUK_SIGNBIT          duk_repl_signbit
-+#define DUK_ISFINITE         duk_repl_isfinite
-+#define DUK_ISNAN            duk_repl_isnan
-+#define DUK_ISINF            duk_repl_isinf
-+#define DUK_FP_NAN           0
-+#define DUK_FP_INFINITE      1
-+#define DUK_FP_ZERO          2
-+#define DUK_FP_SUBNORMAL     3
-+#define DUK_FP_NORMAL        4
-+#else
-+#define DUK_FPCLASSIFY       fpclassify
-+#define DUK_SIGNBIT          signbit
-+#define DUK_ISFINITE         isfinite
-+#define DUK_ISNAN            isnan
-+#define DUK_ISINF            isinf
-+#define DUK_FP_NAN           FP_NAN
-+#define DUK_FP_INFINITE      FP_INFINITE
-+#define DUK_FP_ZERO          FP_ZERO
-+#define DUK_FP_SUBNORMAL     FP_SUBNORMAL
-+#define DUK_FP_NORMAL        FP_NORMAL
-+#endif
-+
-+#if defined(DUK_F_USE_REPL_ALL)
-+#undef DUK_F_USE_REPL_ALL
-+#endif
-+
-+/* Some math functions are C99 only.  This is also an issue with some
-+ * embedded environments using uclibc where uclibc has been configured
-+ * not to provide some functions.  For now, use replacements whenever
-+ * using uclibc.
-+ */
-+#undef DUK_USE_MATH_FMIN
-+#undef DUK_USE_MATH_FMAX
-+#undef DUK_USE_MATH_ROUND
-+#if defined(DUK_F_UCLIBC)
-+/* uclibc may be missing these */
-+#elif defined(DUK_F_AMIGAOS) && defined(DUK_F_VBCC)
-+/* vbcc + AmigaOS may be missing these */
-+#elif !defined(DUK_F_C99) && !defined(DUK_F_CPP11)
-+/* build is not C99 or C++11, play it safe */
-+#else
-+/* C99 or C++11, no known issues */
-+#define DUK_USE_MATH_FMIN
-+#define DUK_USE_MATH_FMAX
-+#define DUK_USE_MATH_ROUND
-+#endif
-+
-+/* These functions don't currently need replacement but are wrapped for
-+ * completeness.  Because these are used as function pointers, they need
-+ * to be defined as concrete C functions (not macros).
-+ */
-+#define DUK_FABS             fabs
-+#define DUK_FMIN             fmin
-+#define DUK_FMAX             fmax
-+#define DUK_FLOOR            floor
-+#define DUK_CEIL             ceil
-+#define DUK_FMOD             fmod
-+#define DUK_POW              pow
-+#define DUK_ACOS             acos
-+#define DUK_ASIN             asin
-+#define DUK_ATAN             atan
-+#define DUK_ATAN2            atan2
-+#define DUK_SIN              sin
-+#define DUK_COS              cos
-+#define DUK_TAN              tan
-+#define DUK_EXP              exp
-+#define DUK_LOG              log
-+#define DUK_SQRT             sqrt
-+
-+/* NetBSD 6.0 x86 (at least) has a few problems with pow() semantics,
-+ * see test-bug-netbsd-math-pow.js.  Use NetBSD specific workaround.
-+ * (This might be a wider problem; if so, generalize the define name.)
-+ */
-+#undef DUK_USE_POW_NETBSD_WORKAROUND
-+#if defined(DUK_F_NETBSD)
-+#define DUK_USE_POW_NETBSD_WORKAROUND
-+#endif
-+
-+/* Rely as little as possible on compiler behavior for NaN comparison,
-+ * signed zero handling, etc.  Currently never activated but may be needed
-+ * for broken compilers.
-+ */
-+#undef DUK_USE_PARANOID_MATH
-+
-+/* There was a curious bug where test-bi-date-canceling.js would fail e.g.
-+ * on 64-bit Ubuntu, gcc-4.8.1, -m32, and no -std=c99.  Some date computations
-+ * using doubles would be optimized which then broke some corner case tests.
-+ * The problem goes away by adding 'volatile' to the datetime computations.
-+ * Not sure what the actual triggering conditions are, but using this on
-+ * non-C99 systems solves the known issues and has relatively little cost
-+ * on other platforms.  See bugs/issue-2e9d9c2d761dabaf8136c0897b91a270d1a47147.yaml.
-+ */
-+#undef DUK_USE_PARANOID_DATE_COMPUTATION
-+#if !defined(DUK_F_C99)
-+#define DUK_USE_PARANOID_DATE_COMPUTATION
-+#endif
-+
-+/*
-+ *  ANSI C string/memory function wrapper defines to allow easier workarounds.
-+ *  Also convenience macros like DUK_MEMZERO which may be mapped to existing
-+ *  platform function to zero memory (like the deprecated bzero).
-+ *
-+ *  For instance, some platforms don't support zero-size memcpy correctly,
-+ *  some arcane uclibc versions have a buggy memcpy (but working memmove)
-+ *  and so on.  Such broken platforms can be dealt with here.
-+ *
-+ *  NOTE: ANSI C (various versions) and some implementations require that the
-+ *  pointer arguments to memset(), memcpy(), and memmove() be valid values
-+ *  even when byte size is 0 (even a NULL pointer is considered invalid in
-+ *  this context).  Zero-size operations as such are allowed, as long as their
-+ *  pointer arguments point to a valid memory area.  The DUK_MEMSET(),
-+ *  DUK_MEMCPY(), and DUK_MEMMOVE() macros require this same behavior, i.e.:
-+ *  (1) pointers must be valid and non-NULL, (2) zero size must otherwise be
-+ *  allowed.  If these are not fulfilled, a macro wrapper is needed.
-+ *
-+ *    http://stackoverflow.com/questions/5243012/is-it-guaranteed-to-be-safe-to-perform-memcpy0-0-0
-+ *    http://lists.cs.uiuc.edu/pipermail/llvmdev/2007-October/011065.html
-+ *
-+ *  Not sure what's the required behavior when a pointer points just past the
-+ *  end of a buffer, which often happens in practice (e.g. zero size memmoves).
-+ *  For example, if allocation size is 3, the following pointer would not
-+ *  technically point to a valid memory byte:
-+ *
-+ *    <-- alloc -->
-+ *    | 0 | 1 | 2 | .....
-+ *                  ^-- p=3, points after last valid byte (2)
-+ *
-+ *  If this is a practical issue, wrappers are again needed.
-+ */
-+
-+typedef FILE duk_file;
-+#define DUK_STDIN       stdin
-+#define DUK_STDOUT      stdout
-+#define DUK_STDERR      stderr
-+
-+/* Special naming to avoid conflict with e.g. DUK_FREE() in duk_heap.h
-+ * (which is unfortunately named).
-+ */
-+#define DUK_ANSI_MALLOC      malloc
-+#define DUK_ANSI_REALLOC     realloc
-+#define DUK_ANSI_CALLOC      calloc
-+#define DUK_ANSI_FREE        free
-+
-+/* Old uclibcs have a broken memcpy so use memmove instead (this is overly
-+ * wide now on purpose):
-+ * http://lists.uclibc.org/pipermail/uclibc-cvs/2008-October/025511.html
-+ */
-+#if defined(DUK_F_UCLIBC)
-+#define DUK_MEMCPY       memmove
-+#else
-+#define DUK_MEMCPY       memcpy
-+#endif
-+
-+#define DUK_MEMMOVE      memmove
-+#define DUK_MEMCMP       memcmp
-+#define DUK_MEMSET       memset
-+#define DUK_STRLEN       strlen
-+#define DUK_STRCMP       strcmp
-+#define DUK_STRNCMP      strncmp
-+#define DUK_PRINTF       printf
-+#define DUK_FPRINTF      fprintf
-+#define DUK_SPRINTF      sprintf
-+
-+#if defined(DUK_F_MSVC)
-+/* _snprintf() does NOT NUL terminate on truncation, but Duktape code never
-+ * assumes that.
-+ * http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010
-+ */
-+#define DUK_SNPRINTF     _snprintf
-+#else
-+#define DUK_SNPRINTF     snprintf
-+#endif
-+
-+#define DUK_VSPRINTF     vsprintf
-+
-+#if defined(DUK_F_MSVC)
-+#if (_MSC_VER < 1600)
-+/* Older MSVC version are missing vsnprintf() but have _vsnprintf(). */
-+#define DUK_VSNPRINTF    _vsnprintf
-+#else
-+#define DUK_VSNPRINTF    vsnprintf
-+#endif
-+#else
-+#define DUK_VSNPRINTF    vsnprintf
-+#endif  /* DUK_F_MSVC */
-+
-+#define DUK_SSCANF       sscanf
-+#define DUK_VSSCANF      vsscanf
-+#define DUK_FOPEN        fopen
-+#define DUK_FCLOSE       fclose
-+#define DUK_FREAD        fread
-+#define DUK_FWRITE       fwrite
-+#define DUK_FSEEK        fseek
-+#define DUK_FTELL        ftell
-+#define DUK_FFLUSH       fflush
-+#define DUK_FPUTC        fputc
-+
-+#define DUK_MEMZERO(p,n) \
-+	DUK_MEMSET((p), 0, (n))
-+
-+/*
-+ *  Avoiding platform function pointers.
-+ *
-+ *  On some platforms built-in functions may be implemented as macros or
-+ *  inline functions, so they can't be necessarily addressed by function
-+ *  pointers.  This is certainly the case with some platform "polyfills"
-+ *  which provide missing C99/C++11 functions through macros, and may be
-+ *  the case with VS2013 (see GH-17).
-+ */
-+
-+/* This is now the default: the cost in footprint is negligible. */
-+#define DUK_USE_AVOID_PLATFORM_FUNCPTRS
-+
-+/*
-+ *  Vararg macro wrappers.  We need va_copy() which is defined in C99 / C++11,
-+ *  so an awkward replacement is needed for pre-C99 / pre-C++11 environments.
-+ *  This will quite likely need portability hacks for some non-C99 environments.
-+ */
-+
-+#if defined(DUK_F_C99) || defined(DUK_F_CPP11)
-+/* C99 / C++11 and above: rely on va_copy() which is required.
-+ * Omit parenthesis on macro right side on purpose to minimize differences
-+ * to direct use.
-+ */
-+#define DUK_VA_COPY(dest,src) va_copy(dest,src)
-+#elif defined(DUK_F_GCC) || defined(DUK_F_CLANG)
-+/* GCC: assume we have __va_copy() in non-C99 mode, which should be correct
-+ * for even quite old GCC versions.  Clang matches GCC behavior.
-+ */
-+#define DUK_VA_COPY(dest,src) __va_copy(dest,src)
-+#else
-+/* Pre-C99: va_list type is implementation dependent.  This replacement
-+ * assumes it is a plain value so that a simple assignment will work.
-+ * This is not the case on all platforms (it may be a single-array element,
-+ * for instance).
-+ */
-+#define DUK_VA_COPY(dest,src) do { (dest) = (src); } while (0)
-+#endif
-+
-+/*
-+ *  Miscellaneous ANSI C or other platform wrappers.
-+ */
-+
-+#define DUK_ABORT        abort
-+#define DUK_EXIT         exit
-+
-+/*
-+ *  Macro hackery to convert e.g. __LINE__ to a string without formatting,
-+ *  see: http://stackoverflow.com/questions/240353/convert-a-preprocessor-token-to-a-string
-+ */
-+
-+#define DUK_F_STRINGIFY_HELPER(x)  #x
-+#define DUK_MACRO_STRINGIFY(x)  DUK_F_STRINGIFY_HELPER(x)
-+
-+/*
-+ *  Cause segfault macro.
-+ *
-+ *  This is optionally used by panic handling to cause the program to segfault
-+ *  (instead of e.g. abort()) on panic.  Valgrind will then indicate the C
-+ *  call stack leading to the panic.
-+ */
-+
-+#define DUK_CAUSE_SEGFAULT()  do { \
-+		*((volatile duk_uint32_t *) NULL) = (duk_uint32_t) 0xdeadbeefUL; \
-+	} while (0)
-+
-+/*
-+ *  Macro for suppressing warnings for potentially unreferenced variables.
-+ *  The variables can be actually unreferenced or unreferenced in some
-+ *  specific cases only; for instance, if a variable is only debug printed,
-+ *  it is unreferenced when debug printing is disabled.
-+ *
-+ *  (Introduced here because it's potentially compiler specific.)
-+ */
-+
-+#define DUK_UNREF(x)  do { \
-+		(void) (x); \
-+	} while (0)
-+
-+/*
-+ *  DUK_NORETURN: macro for declaring a 'noreturn' function.
-+ *  Unfortunately the noreturn declaration may appear in various
-+ *  places of a function declaration, so the solution is to wrap
-+ *  the entire declaration inside the macro.  Compiler support
-+ *  for using a noreturn declaration on function pointers varies;
-+ *  this macro must only be used for actual function declarations.
-+ *
-+ *  http://gcc.gnu.org/onlinedocs/gcc-4.3.2//gcc/Function-Attributes.html
-+ *  http://clang.llvm.org/docs/LanguageExtensions.html
-+ */
-+
-+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 20500L)
-+/* since gcc-2.5 */
-+#define DUK_NORETURN(decl)  decl __attribute__((noreturn))
-+#elif defined(__clang__)
-+/* syntax same as gcc */
-+#define DUK_NORETURN(decl)  decl __attribute__((noreturn))
-+#elif defined(DUK_F_MSVC)
-+/* http://msdn.microsoft.com/en-us/library/aa235362(VS.60).aspx */
-+#define DUK_NORETURN(decl)  __declspec(noreturn) decl
-+#else
-+/* Don't know how to declare a noreturn function, so don't do it; this
-+ * may cause some spurious compilation warnings (e.g. "variable used
-+ * uninitialized").
-+ */
-+#define DUK_NORETURN(decl)  decl
-+#endif
-+
-+/*
-+ *  Macro for stating that a certain line cannot be reached.
-+ *
-+ *  http://gcc.gnu.org/onlinedocs/gcc-4.5.0/gcc/Other-Builtins.html#Other-Builtins
-+ *  http://clang.llvm.org/docs/LanguageExtensions.html
-+ */
-+
-+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L)
-+/* since gcc-4.5 */
-+#define DUK_UNREACHABLE()  do { __builtin_unreachable(); } while(0)
-+#elif defined(__clang__) && defined(__has_builtin)
-+#if __has_builtin(__builtin_unreachable)
-+/* same as gcc */
-+#define DUK_UNREACHABLE()  do { __builtin_unreachable(); } while(0)
-+#endif
-+#else
-+/* unknown */
-+#endif
-+
-+#if !defined(DUK_UNREACHABLE)
-+/* Don't know how to declare unreachable point, so don't do it; this
-+ * may cause some spurious compilation warnings (e.g. "variable used
-+ * uninitialized").
-+ */
-+#define DUK_UNREACHABLE()  /* unreachable */
-+#endif
-+
-+/*
-+ *  Likely and unlikely branches.  Using these is not at all a clear cut case,
-+ *  so the selection is a two-step process: (1) DUK_USE_BRANCH_HINTS is set
-+ *  if the architecture, compiler etc make it useful to use the hints, and (2)
-+ *  a separate check determines how to do them.
-+ *
-+ *  These macros expect the argument to be a relational expression with an
-+ *  integer value.  If used with pointers, you should use an explicit check
-+ *  like:
-+ *
-+ *    if (DUK_LIKELY(ptr != NULL)) { ... }
-+ *
-+ *  instead of:
-+ *
-+ *    if (DUK_LIKELY(ptr)) { ... }
-+ *
-+ *  http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html  (__builtin_expect)
-+ */
-+
-+/* pretty much a placeholder now */
-+#if defined(DUK_F_GCC)
-+#define DUK_USE_BRANCH_HINTS
-+#elif defined(DUK_F_CLANG)
-+#define DUK_USE_BRANCH_HINTS
-+#else
-+#undef DUK_USE_BRANCH_HINTS
-+#endif
-+
-+#if defined(DUK_USE_BRANCH_HINTS)
-+#if defined(DUK_F_GCC_VERSION) && (DUK_F_GCC_VERSION >= 40500L)
-+/* GCC: test not very accurate; enable only in relatively recent builds
-+ * because of bugs in gcc-4.4 (http://lists.debian.org/debian-gcc/2010/04/msg00000.html)
-+ */
-+#define DUK_LIKELY(x)    __builtin_expect((x), 1)
-+#define DUK_UNLIKELY(x)  __builtin_expect((x), 0)
-+#elif defined(DUK_F_CLANG)
-+#define DUK_LIKELY(x)    __builtin_expect((x), 1)
-+#define DUK_UNLIKELY(x)  __builtin_expect((x), 0)
-+#endif
-+#endif  /* DUK_USE_BRANCH_HINTS */
-+
-+#if !defined(DUK_LIKELY)
-+#define DUK_LIKELY(x)    (x)
-+#endif
-+#if !defined(DUK_UNLIKELY)
-+#define DUK_UNLIKELY(x)  (x)
-+#endif
-+
-+/*
-+ *  Function inlining control
-+ *
-+ *  DUK_NOINLINE: avoid inlining a function.
-+ *  DUK_INLINE: suggest inlining a function.
-+ *  DUK_ALWAYS_INLINE: force inlining for critical functions.
-+ */
-+
-+#if defined(DUK_F_CLANG)
-+#define DUK_NOINLINE        __attribute__((noinline))
-+#define DUK_INLINE          inline
-+#define DUK_ALWAYS_INLINE   inline __attribute__((always_inline))
-+#elif defined(DUK_F_GCC) && defined(DUK_F_GCC_VERSION)
-+#if (DUK_F_GCC_VERSION >= 30101)
-+#define DUK_NOINLINE        __attribute__((noinline))
-+#define DUK_INLINE          inline
-+#define DUK_ALWAYS_INLINE   inline __attribute__((always_inline))
-+#endif
-+#endif
-+
-+#if !defined(DUK_NOINLINE)
-+#define DUK_NOINLINE       /*nop*/
-+#define DUK_INLINE         /*nop*/
-+#define DUK_ALWAYS_INLINE  /*nop*/
-+#endif
-+
-+/*
-+ *  Symbol visibility macros
-+ *
-+ *  To avoid C++ declaration issues (see GH-63):
-+ *
-+ *    - Don't use DUK_LOCAL_DECL for local -data symbols- so that you don't
-+ *      end up with both a "static" declaration and a definition.
-+ *
-+ *    - Wrap any DUK_INTERNAL_DECL with a '#if !defined(DUK_SINGLE_FILE)'
-+ *      so that the internal declarations (which would map to "static" in
-+ *      a single file distribution) get dropped.
-+ */
-+
-+/* XXX: user override for these? user override for just using the default visibility macros? */
-+/* XXX: separate macros for function and data may be necessary at some point. */
-+
-+#if defined(DUK_F_GCC_VERSION)
-+#if (DUK_F_GCC_VERSION >= 40000) && !(defined(DUK_F_MINGW) || defined(DUK_F_CYGWIN))
-+/* Might work on earlier versions too but limit to GCC 4+.
-+ * MinGW should use Windows specific __declspec or no visibility attributes at all,
-+ * otherwise: "warning: visibility attribute not supported in this configuration; ignored".
-+ * Same applies to Cygwin GCC.
-+ */
-+#define DUK_F_GCC_SYMBOL_VISIBILITY
-+#endif
-+#endif
-+#if defined(DUK_F_CLANG) && !defined(DUK_F_GCC_SYMBOL_VISIBILITY)
-+#define DUK_F_GCC_SYMBOL_VISIBILITY
-+#endif
-+#if defined(DUK_OPT_DLL_BUILD) && defined(_WIN32) && (defined(_MSC_VER) || defined(__GNUC__))
-+/* __declspec(dllexport) and __declspec(dllimport) only for Windows DLL build.
-+ * MSVC: any minimum version?
-+ * MinGW: no minimum version, even gcc-2.95.3 supported dllimport/dllexport.
-+*/
-+#define DUK_F_MSVC_DLL_SYMBOL_VISIBILITY
-+#endif
-+
-+#if defined(DUK_F_GCC_SYMBOL_VISIBILITY)
-+/* GCC 4+ visibility attributes. */
-+#define DUK_EXTERNAL_DECL  __attribute__ ((visibility("default"))) extern
-+#define DUK_EXTERNAL       __attribute__ ((visibility("default")))
-+#if defined(DUK_SINGLE_FILE)
-+#define DUK_INTERNAL_DECL  static
-+#define DUK_INTERNAL       static
-+#else
-+#define DUK_INTERNAL_DECL  __attribute__ ((visibility("hidden"))) extern
-+#define DUK_INTERNAL       __attribute__ ((visibility("hidden")))
-+#endif
-+#elif defined(DUK_F_MSVC_DLL_SYMBOL_VISIBILITY)
-+/* MSVC dllexport/dllimport: appropriate __declspec depends on whether we're
-+ * compiling Duktape or the application.
-+ */
-+#if defined(DUK_COMPILING_DUKTAPE)
-+#define DUK_EXTERNAL_DECL  extern __declspec(dllexport)
-+#define DUK_EXTERNAL       __declspec(dllexport)
-+#else
-+#define DUK_EXTERNAL_DECL  extern __declspec(dllimport)
-+#define DUK_EXTERNAL       should_not_happen
-+#endif
-+#if defined(DUK_SINGLE_FILE)
-+#define DUK_INTERNAL_DECL  static
-+#define DUK_INTERNAL       static
-+#else
-+#define DUK_INTERNAL_DECL  extern
-+#define DUK_INTERNAL       /*empty*/
-+#endif
-+#else
-+/* Default visibility. */
-+#define DUK_EXTERNAL_DECL  extern
-+#define DUK_EXTERNAL       /*empty*/
-+#if defined(DUK_SINGLE_FILE)
-+#define DUK_INTERNAL_DECL  static
-+#define DUK_INTERNAL       static
-+#else  /* DUK_SINGLE_FILE */
-+#define DUK_INTERNAL_DECL  extern
-+#define DUK_INTERNAL       /*empty*/
-+#endif
-+#endif
-+
-+/* For now, these are shared. */
-+#define DUK_LOCAL_DECL     static
-+#define DUK_LOCAL          static
-+
-+/*
-+ *  __FILE__, __LINE__, __func__ are wrapped.  Especially __func__ is a
-+ *  problem because it is not available even in some compilers which try
-+ *  to be C99 compatible (e.g. VBCC with -c99 option).
-+ */
-+
-+#define DUK_FILE_MACRO  __FILE__
-+
-+#define DUK_LINE_MACRO  __LINE__
-+
-+#if !defined(DUK_F_VBCC) && !defined(DUK_F_MSVC)
-+#define DUK_FUNC_MACRO  __func__
-+#else
-+#define DUK_FUNC_MACRO  "unknown"
-+#endif
-+
-+/*
-+ *  Byteswap macros
-+ *
-+ *  These are here so that inline assembly or other platform functions can be
-+ *  used if available.
-+ */
-+
-+#define DUK_BSWAP32(x) \
-+	((((duk_uint32_t) (x)) >> 24) | \
-+	 ((((duk_uint32_t) (x)) >> 8) & 0xff00UL) | \
-+	 ((((duk_uint32_t) (x)) << 8) & 0xff0000UL) | \
-+	 (((duk_uint32_t) (x)) << 24))
-+
-+#define DUK_BSWAP16(x) \
-+	((duk_uint16_t) (x) >> 8) | \
-+	((duk_uint16_t) (x) << 8)
-+
-+/*
-+ *  Architecture string, human readable value exposed in Duktape.env
-+ */
-+
-+#if defined(DUK_F_X86)
-+#define DUK_USE_ARCH_STRING "x86"
-+#elif defined(DUK_F_X32)
-+#define DUK_USE_ARCH_STRING "x32"
-+#elif defined(DUK_F_X64)
-+#define DUK_USE_ARCH_STRING "x64"
-+#elif defined(DUK_F_ARM)
-+#define DUK_USE_ARCH_STRING "arm"
-+#elif defined(DUK_F_MIPS32)
-+#define DUK_USE_ARCH_STRING "mips32"
-+#elif defined(DUK_F_MIPS64)
-+#define DUK_USE_ARCH_STRING "mips64"
-+#elif defined(DUK_F_SUPERH)
-+#define DUK_USE_ARCH_STRING "sh"
-+#elif defined(DUK_F_M68K)
-+#define DUK_USE_ARCH_STRING "m68k"
-+#elif defined(DUK_F_FLASHPLAYER)
-+#define DUK_USE_ARCH_STRING "flashplayer"
-+#elif defined(DUK_F_EMSCRIPTEN)
-+#define DUK_USE_ARCH_STRING "emscripten"
-+#else
-+#define DUK_USE_ARCH_STRING "unknown"
-+#endif
-+
-+/*
-+ *  OS string, human readable value exposed in Duktape.env
-+ */
-+
-+#if defined(DUK_F_LINUX)
-+#define DUK_USE_OS_STRING "linux"
-+#elif defined(__APPLE__)
-+/* http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor */
-+#if TARGET_IPHONE_SIMULATOR
-+#define DUK_USE_OS_STRING "iphone-sim"
-+#elif TARGET_OS_IPHONE
-+#define DUK_USE_OS_STRING "iphone"
-+#elif TARGET_OS_MAC
-+#define DUK_USE_OS_STRING "ios"
-+#else
-+#define DUK_USE_OS_STRING "ios-unknown"
-+#endif
-+#elif defined(DUK_F_FREEBSD)
-+#define DUK_USE_OS_STRING "freebsd"
-+#elif defined(DUK_F_OPENBSD)
-+#define DUK_USE_OS_STRING "openbsd"
-+#elif defined(DUK_F_NETBSD)
-+#define DUK_USE_OS_STRING "netbsd"
-+#elif defined(DUK_F_BSD)
-+#define DUK_USE_OS_STRING "bsd"
-+#elif defined(DUK_F_UNIX)
-+#define DUK_USE_OS_STRING "unix"
-+#elif defined(DUK_F_WINDOWS)
-+#define DUK_USE_OS_STRING "windows"
-+#elif defined(DUK_F_TOS)
-+#define DUK_USE_OS_STRING "tos"
-+#elif defined(DUK_F_AMIGAOS)
-+#define DUK_USE_OS_STRING "amigaos"
-+#elif defined(DUK_F_QNX)
-+#define DUK_USE_OS_STRING "qnx"
-+#elif defined(DUK_F_TINSPIRE)
-+#define DUK_USE_OS_STRING "tinspire"
-+#else
-+#define DUK_USE_OS_STRING "unknown"
-+#endif
-+
-+/*
-+ *  Compiler string, human readable value exposed in Duktape.env
-+ */
-+
-+#if defined(DUK_F_MINGW)
-+#define DUK_USE_COMPILER_STRING "mingw"
-+#elif defined(DUK_F_GCC)
-+#if defined(DUK_F_CPP)
-+#define DUK_USE_COMPILER_STRING "g++"
-+#else
-+#define DUK_USE_COMPILER_STRING "gcc"
-+#endif
-+#elif defined(DUK_F_CLANG)
-+#define DUK_USE_COMPILER_STRING "clang"
-+#elif defined(DUK_F_MSVC)
-+#define DUK_USE_COMPILER_STRING "msvc"
-+#elif defined(DUK_F_VBCC)
-+#define DUK_USE_COMPILER_STRING "vbcc"
-+#else
-+#define DUK_USE_COMPILER_STRING "unknown"
-+#endif
-+
-+/*
-+ *  Long control transfer, setjmp/longjmp or alternatives
-+ *
-+ *  Signal mask is not saved (when that can be communicated to the platform)
-+ */
-+
-+/* dummy non-zero value to be used as an argument for longjmp(), see man longjmp */
-+#define DUK_LONGJMP_DUMMY_VALUE  1
-+
-+#if defined(DUK_OPT_SETJMP)
-+#define DUK_USE_SETJMP
-+#elif defined(DUK_OPT_UNDERSCORE_SETJMP)
-+#define DUK_USE_UNDERSCORE_SETJMP
-+#elif defined(DUK_OPT_SIGSETJMP)
-+#define DUK_USE_SIGSETJMP
-+#elif defined(__APPLE__)
-+/* Use _setjmp() on Apple by default, see GH-55. */
-+#define DUK_USE_UNDERSCORE_SETJMP
-+#else
-+/* The most portable default is setjmp(). */
-+#define DUK_USE_SETJMP
-+#endif
-+
-+#if defined(DUK_USE_UNDERSCORE_SETJMP)
-+#define DUK_SETJMP(jb)        _setjmp((jb))
-+#define DUK_LONGJMP(jb)       _longjmp((jb), DUK_LONGJMP_DUMMY_VALUE)
-+#elif defined(DUK_USE_SIGSETJMP)
-+#define DUK_SETJMP(jb)        sigsetjmp((jb), 0 /*savesigs*/)
-+#define DUK_LONGJMP(jb)       siglongjmp((jb), DUK_LONGJMP_DUMMY_VALUE)
-+#elif defined(DUK_USE_SETJMP)
-+#define DUK_SETJMP(jb)        setjmp((jb))
-+#define DUK_LONGJMP(jb)       longjmp((jb), DUK_LONGJMP_DUMMY_VALUE)
-+#else
-+#error internal error
-+#endif
-+
-+/*
-+ *  Target info string
-+ */
-+
-+#if defined(DUK_OPT_TARGET_INFO)
-+#define DUK_USE_TARGET_INFO DUK_OPT_TARGET_INFO
-+#else
-+#define DUK_USE_TARGET_INFO "unknown"
-+#endif
-+
-+/*
-+ *  Speed/size and other performance options
-+ */
-+
-+/* Use fast ("inline") refcount operations instead of calling out to helpers
-+ * by default.  The difference in binary size is small (~1kB on x64).
-+ */
-+#define DUK_USE_FAST_REFCOUNT_DEFAULT
-+
-+/* Assert for valstack space but don't check for it in non-assert build.
-+ * Valstack overruns (writing beyond checked space) is memory unsafe and
-+ * potentially a segfault.  Produces a smaller and faster binary.
-+ * (In practice the speed difference is small with -O3 so default to
-+ * safer behavior for now.)
-+ */
-+#undef DUK_USE_VALSTACK_UNSAFE
-+
-+/* Catch-all flag which can be used to choose between variant algorithms
-+ * where a speed-size tradeoff exists (e.g. lookup tables).  When it really
-+ * matters, specific use flags may be appropriate.
-+ */
-+#define DUK_USE_PREFER_SIZE
-+
-+/*
-+ *  Tagged type representation (duk_tval)
-+ */
-+
-+#undef DUK_USE_PACKED_TVAL
-+
-+#if defined(DUK_USE_PACKED_TVAL_POSSIBLE) && !defined(DUK_OPT_NO_PACKED_TVAL)
-+#define DUK_USE_PACKED_TVAL
-+#endif
-+
-+/* Support for 48-bit signed integer duk_tval with transparent semantics. */
-+#undef DUK_USE_FASTINT
-+#if defined(DUK_OPT_FASTINT)
-+#if !defined(DUK_F_HAVE_64BIT)
-+#error DUK_OPT_FASTINT requires 64-bit integer type support at the moment
-+#endif
-+#define DUK_USE_FASTINT
-+#endif
-+
-+/*
-+ *  Memory management options
-+ */
-+
-+#define DUK_USE_REFERENCE_COUNTING
-+#define DUK_USE_DOUBLE_LINKED_HEAP
-+#define DUK_USE_MARK_AND_SWEEP
-+#define DUK_USE_MS_STRINGTABLE_RESIZE
-+
-+#if defined(DUK_OPT_NO_REFERENCE_COUNTING)
-+#undef DUK_USE_REFERENCE_COUNTING
-+#undef DUK_USE_DOUBLE_LINKED_HEAP
-+/* XXX: undef DUK_USE_MS_STRINGTABLE_RESIZE as it is more expensive
-+ * with more frequent mark-and-sweeps?
-+ */
-+#endif
-+
-+#if defined(DUK_OPT_NO_MARK_AND_SWEEP)
-+#undef DUK_USE_MARK_AND_SWEEP
-+#endif
-+
-+#if defined(DUK_USE_MARK_AND_SWEEP)
-+#define DUK_USE_VOLUNTARY_GC
-+#if defined(DUK_OPT_NO_VOLUNTARY_GC)
-+#undef DUK_USE_VOLUNTARY_GC
-+#endif
-+#endif
-+
-+#if !defined(DUK_USE_MARK_AND_SWEEP) && !defined(DUK_USE_REFERENCE_COUNTING)
-+#error must have either mark-and-sweep or reference counting enabled
-+#endif
-+
-+#if defined(DUK_OPT_NO_MS_STRINGTABLE_RESIZE)
-+#undef DUK_USE_MS_STRINGTABLE_RESIZE
-+#endif
-+
-+#undef DUK_USE_GC_TORTURE
-+#if defined(DUK_OPT_GC_TORTURE)
-+#define DUK_USE_GC_TORTURE
-+#endif
-+
-+/*
-+ *  String table options
-+ */
-+
-+#if defined(DUK_OPT_STRTAB_CHAIN) && defined(DUK_OPT_STRTAB_CHAIN_SIZE)
-+/* Low memory algorithm: separate chaining using arrays, fixed size hash */
-+#define DUK_USE_STRTAB_CHAIN
-+#define DUK_USE_STRTAB_CHAIN_SIZE  DUK_OPT_STRTAB_CHAIN_SIZE
-+#else
-+/* Default algorithm: open addressing (probing) */
-+#define DUK_USE_STRTAB_PROBE
-+#endif
-+
-+/*
-+ *  Error handling options
-+ */
-+
-+#define DUK_USE_AUGMENT_ERROR_CREATE
-+#define DUK_USE_AUGMENT_ERROR_THROW
-+#define DUK_USE_TRACEBACKS
-+#define DUK_USE_ERRCREATE
-+#define DUK_USE_ERRTHROW
-+
-+#define DUK_USE_VERBOSE_ERRORS
-+
-+#if defined(DUK_OPT_NO_AUGMENT_ERRORS)
-+#undef DUK_USE_AUGMENT_ERROR_CREATE
-+#undef DUK_USE_AUGMENT_ERROR_THROW
-+#undef DUK_USE_TRACEBACKS
-+#undef DUK_USE_ERRCREATE
-+#undef DUK_USE_ERRTHROW
-+#elif defined(DUK_OPT_NO_TRACEBACKS)
-+#undef DUK_USE_TRACEBACKS
-+#endif
-+
-+#if defined(DUK_OPT_NO_VERBOSE_ERRORS)
-+#undef DUK_USE_VERBOSE_ERRORS
-+#endif
-+
-+#if defined(DUK_USE_TRACEBACKS)
-+#if defined(DUK_OPT_TRACEBACK_DEPTH)
-+#define DUK_USE_TRACEBACK_DEPTH  DUK_OPT_TRACEBACK_DEPTH
-+#else
-+#define DUK_USE_TRACEBACK_DEPTH  10
-+#endif
-+#endif
-+
-+/* Include messages in executor internal errors. */
-+#define DUK_USE_VERBOSE_EXECUTOR_ERRORS
-+
-+/*
-+ *  Execution and debugger options
-+ */
-+
-+#undef DUK_USE_INTERRUPT_COUNTER
-+#if defined(DUK_OPT_INTERRUPT_COUNTER)
-+#define DUK_USE_INTERRUPT_COUNTER
-+#endif
-+
-+#undef DUK_USE_EXEC_TIMEOUT_CHECK
-+#if defined(DUK_OPT_EXEC_TIMEOUT_CHECK)
-+#define DUK_USE_EXEC_TIMEOUT_CHECK(udata)  DUK_OPT_EXEC_TIMEOUT_CHECK((udata))
-+#endif
-+
-+#undef DUK_USE_DEBUGGER_SUPPORT
-+#if defined(DUK_OPT_DEBUGGER_SUPPORT)
-+#define DUK_USE_DEBUGGER_SUPPORT
-+#endif
-+
-+#undef DUK_USE_DEBUGGER_FWD_PRINTALERT
-+#if defined(DUK_OPT_DEBUGGER_SUPPORT) && defined(DUK_OPT_DEBUGGER_FWD_PRINTALERT)
-+#define DUK_USE_DEBUGGER_FWD_PRINTALERT
-+#endif
-+
-+#undef DUK_USE_DEBUGGER_FWD_LOGGING
-+#if defined(DUK_OPT_DEBUGGER_SUPPORT) && defined(DUK_OPT_DEBUGGER_FWD_LOGGING)
-+#define DUK_USE_DEBUGGER_FWD_LOGGING
-+#endif
-+
-+/* DumpHeap is optional because it's not always needed and has a relatively
-+ * large footprint.
-+ */
-+#undef DUK_USE_DEBUGGER_DUMPHEAP
-+#if defined(DUK_OPT_DEBUGGER_DUMPHEAP)
-+#define DUK_USE_DEBUGGER_DUMPHEAP
-+#endif
-+
-+/* Debugger transport read/write torture. */
-+#undef DUK_USE_DEBUGGER_TRANSPORT_TORTURE
-+#if defined(DUK_OPT_DEBUGGER_TRANSPORT_TORTURE)
-+#define DUK_USE_DEBUGGER_TRANSPORT_TORTURE
-+#endif
-+
-+/* For opcodes with indirect indices, check final index against stack size.
-+ * This should not be necessary because the compiler is trusted, and we don't
-+ * bound check non-indirect indices either.
-+ */
-+#undef DUK_USE_EXEC_INDIRECT_BOUND_CHECK
-+#if defined(DUK_OPT_DEBUG) || defined(DUK_OPT_ASSERTIONS)
-+/* Enabled with debug/assertions just so that any issues can be caught. */
-+#define DUK_USE_EXEC_INDIRECT_BOUND_CHECK
-+#endif
-+
-+/*
-+ *  Debug printing and assertion options
-+ */
-+
-+#undef DUK_USE_DEBUG
-+#undef DUK_USE_DPRINT
-+#undef DUK_USE_DDPRINT
-+#undef DUK_USE_DDDPRINT
-+#undef DUK_USE_DPRINT_RDTSC
-+#undef DUK_USE_ASSERTIONS
-+
-+/* Global debug enable.  Compile must be clean on C99 regardless of whether or
-+ * not debugging is enabled.  On non-C99 platforms compile should be clean with
-+ * debugging disabled but may produce warnings with debugging enabled (related
-+ * to debug macro hackery and such).
-+ */
-+#if defined(DUK_OPT_DEBUG)
-+#define DUK_USE_DEBUG
-+#endif
-+
-+#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DPRINT)
-+#define DUK_USE_DPRINT
-+#endif
-+#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DDPRINT)
-+#define DUK_USE_DDPRINT
-+#endif
-+#if defined(DUK_OPT_DEBUG) && defined(DUK_OPT_DDDPRINT)
-+#define DUK_USE_DDDPRINT
-+#endif
-+
-+#undef DUK_USE_DPRINT_COLORS
-+#if defined(DUK_OPT_DPRINT_COLORS)
-+#define DUK_USE_DPRINT_COLORS
-+#endif
-+
-+#if defined(DUK_RDTSC_AVAILABLE) && defined(DUK_OPT_DPRINT_RDTSC)
-+#define DUK_USE_DPRINT_RDTSC
-+#else
-+#undef DUK_USE_DPRINT_RDTSC
-+#endif
-+
-+#if defined(DUK_OPT_ASSERTIONS)
-+#define DUK_USE_ASSERTIONS
-+#endif
-+
-+/* The static buffer for debug printing is quite large by default, so there
-+ * is an option to shrink it manually for constrained builds.
-+ */
-+#if defined(DUK_OPT_DEBUG_BUFSIZE)
-+#define DUK_USE_DEBUG_BUFSIZE  DUK_OPT_DEBUG_BUFSIZE
-+#else
-+#define DUK_USE_DEBUG_BUFSIZE  65536L
-+#endif
-+
-+/*
-+ *  Ecmascript features / compliance options
-+ */
-+
-+#if defined(DUK_F_BCC)
-+/* Math built-in is stubbed out on BCC to allow compiler torture testing. */
-+#else
-+#define DUK_USE_MATH_BUILTIN
-+#endif
-+
-+#define DUK_USE_STRICT_DECL
-+#if defined(DUK_OPT_NO_STRICT_DECL)
-+#undef DUK_USE_STRICT_DECL
-+#endif
-+
-+#define DUK_USE_REGEXP_SUPPORT
-+#if defined(DUK_OPT_NO_REGEXP_SUPPORT)
-+#undef DUK_USE_REGEXP_SUPPORT
-+#endif
-+
-+#undef DUK_USE_STRICT_UTF8_SOURCE
-+#if defined(DUK_OPT_STRICT_UTF8_SOURCE)
-+#define DUK_USE_STRICT_UTF8_SOURCE
-+#endif
-+
-+#define DUK_USE_OCTAL_SUPPORT
-+#if defined(DUK_OPT_NO_OCTAL_SUPPORT)
-+#undef DUK_USE_OCTAL_SUPPORT
-+#endif
-+
-+#define DUK_USE_SOURCE_NONBMP
-+#if defined(DUK_OPT_NO_SOURCE_NONBMP)
-+#undef DUK_USE_SOURCE_NONBMP
-+#endif
-+
-+#define DUK_USE_BROWSER_LIKE
-+#if defined(DUK_OPT_NO_BROWSER_LIKE)
-+#undef DUK_USE_BROWSER_LIKE
-+#endif
-+
-+/* E5/E5.1 Section B features. */
-+#define DUK_USE_SECTION_B
-+#if defined(DUK_OPT_NO_SECTION_B)
-+#undef DUK_USE_SECTION_B
-+#endif
-+
-+/* Non-standard regexp parsing features. */
-+#define DUK_USE_NONSTD_REGEXP_DOLLAR_ESCAPE
-+
-+/* Treat function statements (function declarations outside top level of
-+ * Program or FunctionBody) same as normal function declarations.  This is
-+ * also V8 behavior.  See test-dev-func-decl-outside-top.js.
-+ */
-+#define DUK_USE_NONSTD_FUNC_STMT
-+#if defined(DUK_OPT_NO_NONSTD_FUNC_STMT)
-+#undef DUK_USE_NONSTD_FUNC_STMT
-+#endif
-+
-+/* Array.prototype.splice() non-standard but real world compatible behavior
-+ * when deleteCount is omitted.
-+ */
-+#define DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
-+#if defined(DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT)
-+#undef DUK_USE_NONSTD_ARRAY_SPLICE_DELCOUNT
-+#endif
-+
-+/* Array.prototype.concat() non-standard but real world compatible behavior
-+ * for non-existent trailing elements.
-+ */
-+#define DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER
-+#if defined(DUK_OPT_NO_NONSTD_ARRAY_CONCAT_TRAILER)
-+#undef DUK_USE_NONSTD_ARRAY_CONCAT_TRAILER
-+#endif
-+
-+/* Array.prototype.map() non-standard but real world compatible behavior
-+ * for non-existent trailing elements.
-+ */
-+#define DUK_USE_NONSTD_ARRAY_MAP_TRAILER
-+#if defined(DUK_OPT_NO_NONSTD_ARRAY_MAP_TRAILER)
-+#undef DUK_USE_NONSTD_ARRAY_MAP_TRAILER
-+#endif
-+
-+/* Non-standard 'caller' property for function instances, see
-+ * test-bi-function-nonstd-caller-prop.js.
-+ */
-+#undef DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+#if defined(DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY)
-+#define DUK_USE_NONSTD_FUNC_CALLER_PROPERTY
-+#endif
-+
-+/* Non-standard Object.prototype.__proto__ (ES6 draft), see
-+ * test-bi-object-proto-__proto__.js.
-+ */
-+#define DUK_USE_ES6_OBJECT_PROTO_PROPERTY
-+#if defined(DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY)
-+#undef DUK_USE_ES6_OBJECT_PROTO_PROPERTY
-+#endif
-+
-+/* Non-standard Object.setPrototypeOf (ES6 draft), see
-+ * test-bi-object-setprototypeof.js.
-+ */
-+#define DUK_USE_ES6_OBJECT_SETPROTOTYPEOF
-+#if defined(DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF)
-+#undef DUK_USE_ES6_OBJECT_SETPROTOTYPEOF
-+#endif
-+
-+/* ES6 Proxy object (subset for now). */
-+#define DUK_USE_ES6_PROXY
-+#if defined(DUK_OPT_NO_ES6_PROXY)
-+#undef DUK_USE_ES6_PROXY
-+#endif
-+
-+/* Record pc-to-line information. */
-+#define DUK_USE_PC2LINE
-+#if defined(DUK_OPT_NO_PC2LINE)
-+#undef DUK_USE_PC2LINE
-+#endif
-+
-+/* Non-standard function 'source' property. */
-+#undef DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY
-+#if defined(DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY)
-+#define DUK_USE_NONSTD_FUNC_SOURCE_PROPERTY
-+#endif
-+
-+/* CommonJS modules */
-+#define DUK_USE_COMMONJS_MODULES
-+#if defined(DUK_OPT_NO_COMMONJS_MODULES)
-+#undef DUK_USE_COMMONJS_MODULES
-+#endif
-+
-+/* Additional key argument to setter/getter calls when triggered by property
-+ * accesses.
-+ */
-+
-+#define DUK_USE_NONSTD_GETTER_KEY_ARGUMENT
-+#define DUK_USE_NONSTD_SETTER_KEY_ARGUMENT
-+#if defined(DUK_OPT_NO_NONSTD_ACCESSOR_KEY_ARGUMENT)
-+#undef DUK_USE_NONSTD_GETTER_KEY_ARGUMENT
-+#undef DUK_USE_NONSTD_SETTER_KEY_ARGUMENT
-+#endif
-+
-+/* JSON escaping of U+2028 and U+2029.
-+ */
-+
-+#define DUK_USE_NONSTD_JSON_ESC_U2028_U2029
-+#if defined(DUK_OPT_NO_NONSTD_JSON_ESC_U2028_U2029)
-+#undef DUK_USE_NONSTD_JSON_ESC_U2028_U2029
-+#endif
-+
-+/* Allow 32-bit codepoints in String.fromCharCode. */
-+#define DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT
-+#if defined(DUK_OPT_NO_NONSTD_STRING_FROMCHARCODE_32BIT)
-+#undef DUK_USE_NONSTD_STRING_FROMCHARCODE_32BIT
-+#endif
-+
-+/* Non-standard array fast path write behavior: when writing to numeric
-+ * indexes of an Array instance, assume Array.prototype doesn't have
-+ * conflicting properties (e.g. a non-writable property "7").
-+ */
-+#define DUK_USE_NONSTD_ARRAY_WRITE
-+#if defined(DUK_OPT_NO_NONSTD_ARRAY_WRITE)
-+#undef DUK_USE_NONSTD_ARRAY_WRITE
-+#endif
-+
-+/*
-+ *  Tailcalls
-+ */
-+
-+/* Tailcalls are enabled by default.  The non-standard function 'caller'
-+ * property feature conflicts with tailcalls quite severely so tailcalls
-+ * are disabled if the 'caller' property is enabled.
-+ */
-+#define DUK_USE_TAILCALL
-+#if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
-+#undef DUK_USE_TAILCALL
-+#endif
-+
-+/*
-+ *  Deep vs. shallow stack.
-+ *
-+ *  Some embedded platforms have very shallow stack (e.g. 64kB); default to
-+ *  a shallow stack on unknown platforms or known embedded platforms.
-+ */
-+
-+#if defined(DUK_F_LINUX) || defined(DUK_F_BSD) || defined(DUK_F_WINDOWS) || \
-+    defined(DUK_OPT_DEEP_C_STACK)
-+#define DUK_USE_DEEP_C_STACK
-+#else
-+#undef DUK_USE_DEEP_C_STACK
-+#endif
-+
-+/*
-+ *  Ecmascript compiler
-+ */
-+
-+/* Ensure final bytecode never exceeds a certain byte size and never uses
-+ * line numbers above a certain limit.  This ensures that there is no need
-+ * to deal with unbounded ranges in e.g. pc2line data structures.  For now,
-+ * limits are set so that signed 32-bit values can represent line number
-+ * and byte offset with room to spare.
-+ */
-+#define DUK_USE_ESBC_LIMITS
-+#define DUK_USE_ESBC_MAX_LINENUMBER  0x7fff0000L
-+#define DUK_USE_ESBC_MAX_BYTES       0x7fff0000L
-+
-+#undef DUK_USE_SHUFFLE_TORTURE
-+#if defined(DUK_OPT_SHUFFLE_TORTURE)
-+#define DUK_USE_SHUFFLE_TORTURE
-+#endif
-+
-+/*
-+ *  User panic handler, panic exit behavior for default panic handler
-+ */
-+
-+#undef DUK_USE_PANIC_HANDLER
-+#if defined(DUK_OPT_PANIC_HANDLER)
-+#define DUK_USE_PANIC_HANDLER(code,msg) DUK_OPT_PANIC_HANDLER((code),(msg))
-+#endif
-+
-+#undef DUK_USE_PANIC_ABORT
-+#undef DUK_USE_PANIC_EXIT
-+#undef DUK_USE_PANIC_SEGFAULT
-+
-+#if defined(DUK_OPT_SEGFAULT_ON_PANIC)
-+#define DUK_USE_PANIC_SEGFAULT
-+#else
-+#define DUK_USE_PANIC_ABORT
-+#endif
-+
-+/*
-+ *  File I/O support.  This is now used in a few API calls to e.g. push
-+ *  a string from file contents or eval a file.  For portability it must
-+ *  be possible to disable I/O altogether.
-+ */
-+
-+#undef DUK_USE_FILE_IO
-+#if !defined(DUK_OPT_NO_FILE_IO)
-+#define DUK_USE_FILE_IO
-+#endif
-+
-+/*
-+ *  Optional run-time self tests executed when a heap is created.  Some
-+ *  platform/compiler issues cannot be determined at compile time.  One
-+ *  particular example is the bug described in misc/clang_aliasing.c.
-+ */
-+
-+#undef DUK_USE_SELF_TESTS
-+#if defined(DUK_OPT_SELF_TESTS)
-+#define DUK_USE_SELF_TESTS
-+#endif
-+
-+/* Double aliasing testcase fails when Emscripten-generated code is run
-+ * on Firefox.  This is not fatal because it only affects packed duk_tval
-+ * which we avoid with Emscripten.
-+ */
-+#undef DUK_USE_NO_DOUBLE_ALIASING_SELFTEST
-+#if defined(DUK_F_EMSCRIPTEN)
-+#define DUK_USE_NO_DOUBLE_ALIASING_SELFTEST
-+#endif
-+
-+/*
-+ *  Codecs
-+ */
-+
-+#define DUK_USE_JX
-+#if defined(DUK_OPT_NO_JX)
-+#undef DUK_USE_JX
-+#endif
-+
-+#define DUK_USE_JC
-+#if defined(DUK_OPT_NO_JC)
-+#undef DUK_USE_JC
-+#endif
-+
-+/*
-+ *  InitJS code
-+ */
-+
-+/* Always use the built-in InitJS code for now. */
-+#define DUK_USE_BUILTIN_INITJS
-+
-+/* User provided InitJS. */
-+#undef DUK_USE_USER_INITJS
-+#if defined(DUK_OPT_USER_INITJS)
-+#define DUK_USE_USER_INITJS (DUK_OPT_USER_INITJS)
-+#endif
-+
-+/*
-+ *  External string data support
-+ *
-+ *  Allow duk_hstrings to store data also behind an external pointer (see
-+ *  duk_hstring_external).  This increases code size slightly but is useful
-+ *  in low memory environments where memory is more limited than flash.
-+ */
-+
-+#undef DUK_USE_HSTRING_EXTDATA
-+#if defined(DUK_OPT_EXTERNAL_STRINGS)
-+#define DUK_USE_HSTRING_EXTDATA
-+#endif
-+
-+#undef DUK_USE_EXTSTR_INTERN_CHECK
-+#if defined(DUK_OPT_EXTERNAL_STRINGS) && defined(DUK_OPT_EXTSTR_INTERN_CHECK)
-+#define DUK_USE_EXTSTR_INTERN_CHECK(udata,ptr,len) DUK_OPT_EXTSTR_INTERN_CHECK((udata), (ptr), (len))
-+#endif
-+
-+#undef DUK_USE_EXTSTR_FREE
-+#if defined(DUK_OPT_EXTERNAL_STRINGS) && defined(DUK_OPT_EXTSTR_FREE)
-+#define DUK_USE_EXTSTR_FREE(udata,ptr) DUK_OPT_EXTSTR_FREE((udata), (ptr))
-+#endif
-+
-+/*
-+ *  Lightweight functions
-+ */
-+
-+/* Force built-ins to use lightfunc function pointers when possible.  This
-+ * makes the built-in functions non-compliant with respect to their property
-+ * values and such, but is very useful in low memory environments (can save
-+ * around 14kB of initial RAM footprint).
-+ */
-+#undef DUK_USE_LIGHTFUNC_BUILTINS
-+#if defined(DUK_OPT_LIGHTFUNC_BUILTINS)
-+#define DUK_USE_LIGHTFUNC_BUILTINS
-+#endif
-+
-+/*
-+ *  Pointer compression and 16-bit header fields for low memory environments
-+ */
-+
-+#undef DUK_USE_HEAPPTR16
-+#undef DUK_USE_HEAPPTR_ENC16
-+#undef DUK_USE_HEAPPTR_DEC16
-+#if defined(DUK_OPT_HEAPPTR16) && defined(DUK_OPT_HEAPPTR_ENC16) && defined(DUK_OPT_HEAPPTR_DEC16)
-+#define DUK_USE_HEAPPTR16
-+#define DUK_USE_HEAPPTR_ENC16(udata,ptr) DUK_OPT_HEAPPTR_ENC16((udata),(ptr))
-+#define DUK_USE_HEAPPTR_DEC16(udata,ptr) DUK_OPT_HEAPPTR_DEC16((udata),(ptr))
-+#endif
-+
-+#undef DUK_USE_DATAPTR16
-+#undef DUK_USE_DATAPTR_ENC16
-+#undef DUK_USE_DATAPTR_DEC16
-+#if defined(DUK_OPT_DATAPTR16) && defined(DUK_OPT_DATAPTR_ENC16) && defined(DUK_OPT_DATAPTR_DEC16)
-+#define DUK_USE_DATAPTR16
-+#define DUK_USE_DATAPTR_ENC16(udata,ptr) DUK_OPT_DATAPTR_ENC16((udata),(ptr))
-+#define DUK_USE_DATAPTR_DEC16(udata,ptr) DUK_OPT_DATAPTR_DEC16((udata),(ptr))
-+#endif
-+
-+#undef DUK_USE_FUNCPTR16
-+#undef DUK_USE_FUNCPTR_ENC16
-+#undef DUK_USE_FUNCPTR_DEC16
-+#if defined(DUK_OPT_FUNCPTR16) && defined(DUK_OPT_FUNCPTR_ENC16) && defined(DUK_OPT_FUNCPTR_DEC16)
-+#define DUK_USE_FUNCPTR16
-+#define DUK_USE_FUNCPTR_ENC16(udata,ptr) DUK_OPT_FUNCPTR_ENC16((udata),(ptr))
-+#define DUK_USE_FUNCPTR_DEC16(udata,ptr) DUK_OPT_FUNCPTR_DEC16((udata),(ptr))
-+#endif
-+
-+#undef DUK_USE_REFCOUNT16
-+#if defined(DUK_OPT_REFCOUNT16)
-+#define DUK_USE_REFCOUNT16
-+#endif
-+
-+#undef DUK_USE_STRHASH16
-+#if defined(DUK_OPT_STRHASH16)
-+#define DUK_USE_STRHASH16
-+#endif
-+
-+#undef DUK_USE_STRLEN16
-+#if defined(DUK_OPT_STRLEN16)
-+#define DUK_USE_STRLEN16
-+#endif
-+
-+#undef DUK_USE_BUFLEN16
-+#if defined(DUK_OPT_BUFLEN16)
-+#define DUK_USE_BUFLEN16
-+#endif
-+
-+#undef DUK_USE_OBJSIZES16
-+#if defined(DUK_OPT_OBJSIZES16)
-+#define DUK_USE_OBJSIZES16
-+#endif
-+
-+/* For now, hash part is dropped if and only if 16-bit object fields are used. */
-+#define DUK_USE_HOBJECT_HASH_PART
-+#if defined(DUK_USE_OBJSIZES16)
-+#undef DUK_USE_HOBJECT_HASH_PART
-+#endif
-+
-+/*
-+ *  Miscellaneous
-+ */
-+
-+#define DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS
-+#undef DUK_USE_EXPLICIT_NULL_INIT
-+
-+#if !defined(DUK_USE_PACKED_TVAL)
-+#define DUK_USE_EXPLICIT_NULL_INIT
-+#endif
-+
-+#define DUK_USE_ZERO_BUFFER_DATA
-+#if defined(DUK_OPT_NO_ZERO_BUFFER_DATA)
-+#undef DUK_USE_ZERO_BUFFER_DATA
-+#endif
-+
-+#undef DUK_USE_VARIADIC_MACROS
-+#if defined(DUK_F_C99) || (defined(DUK_F_CPP11) && defined(__GNUC__))
-+#define DUK_USE_VARIADIC_MACROS
-+#endif
-+#if defined(_MSC_VER) && !defined(DUK_USE_VARIADIC_MACROS)
-+#if (_MSC_VER >= 1400)
-+/* VS2005+ should have variadic macros even when they're not C99. */
-+#define DUK_USE_VARIADIC_MACROS
-+#endif
-+#endif
-+
-+/*
-+ *  Variable size array initialization.
-+ *
-+ *  Variable size array at the end of a structure is nonportable.
-+ *  There are three alternatives:
-+ *
-+ *    1) C99 (flexible array member): char buf[]
-+ *    2) Compiler specific (e.g. GCC): char buf[0]
-+ *    3) Portable but wastes memory / complicates allocation: char buf[1]
-+ */
-+
-+/* XXX: Currently unused, only hbuffer.h needed this at some point. */
-+#undef DUK_USE_FLEX_C99
-+#undef DUK_USE_FLEX_ZEROSIZE
-+#undef DUK_USE_FLEX_ONESIZE
-+#if defined(DUK_F_C99)
-+#define DUK_USE_FLEX_C99
-+#elif defined(__GNUC__)
-+#define DUK_USE_FLEX_ZEROSIZE
-+#else
-+#define DUK_USE_FLEX_ONESIZE
-+#endif
-+
-+/*
-+ *  GCC pragmas
-+ */
-+
-+/* XXX: GCC pragma inside a function fails in some earlier GCC versions (e.g. gcc 4.5).
-+ * This is very approximate but allows clean builds for development right now.
-+ */
-+/* http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html */
-+#if defined(__GNUC__) && defined(__GNUC_MINOR__) && (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)
-+#define DUK_USE_GCC_PRAGMAS
-+#else
-+#undef DUK_USE_GCC_PRAGMAS
-+#endif
-+
-+/*
-+ *  User declarations
-+ */
-+
-+#if defined(DUK_OPT_DECLARE)
-+#define DUK_USE_USER_DECLARE() DUK_OPT_DECLARE
-+#else
-+#define DUK_USE_USER_DECLARE() /* no user declarations */
-+#endif
-+
-+/*
-+ *  Alternative customization header
-+ *
-+ *  If you want to modify the final DUK_USE_xxx flags directly (without
-+ *  using the available DUK_OPT_Xxx flags), define DUK_OPT_HAVE_CUSTOM_H
-+ *  and tweak the final flags there.
-+ */
-+
-+#if defined(DUK_OPT_HAVE_CUSTOM_H)
-+#include "duk_custom.h"
-+#endif
-+
-+#endif  /* DUK_FEATURES_H_INCLUDED */
-+
-+/*
-+ *  BEGIN PUBLIC API
-+ */
-+
-+#ifndef DUK_API_PUBLIC_H_INCLUDED
-+#define DUK_API_PUBLIC_H_INCLUDED
-+
-+/*
-+ *  Avoid C++ name mangling
-+ */
-+
-+#ifdef __cplusplus
-+extern "C" {
-+#endif
-+
-+/*
-+ *  Some defines forwarded from feature detection
-+ */
-+
-+#undef DUK_API_VARIADIC_MACROS
-+#ifdef DUK_USE_VARIADIC_MACROS
-+#define DUK_API_VARIADIC_MACROS
-+#endif
-+
-+#define DUK_API_NORETURN(decl) DUK_NORETURN(decl)
-+
-+/*
-+ *  Public API specific typedefs
-+ *
-+ *  (duk_context *) maps directly to internal type (duk_hthread *).
-+ *  Currently only primitive typedefs have a '_t' suffix.
-+ *
-+ *  Many types are wrapped by Duktape for portability to rare platforms
-+ *  where e.g. 'int' is a 16-bit type.  See practical typing discussion
-+ *  in Duktape web documentation.
-+ */
-+
-+struct duk_memory_functions;
-+struct duk_function_list_entry;
-+struct duk_number_list_entry;
-+
-+typedef void duk_context;
-+typedef struct duk_memory_functions duk_memory_functions;
-+typedef struct duk_function_list_entry duk_function_list_entry;
-+typedef struct duk_number_list_entry duk_number_list_entry;
-+
-+typedef duk_ret_t (*duk_c_function)(duk_context *ctx);
-+typedef void *(*duk_alloc_function) (void *udata, duk_size_t size);
-+typedef void *(*duk_realloc_function) (void *udata, void *ptr, duk_size_t size);
-+typedef void (*duk_free_function) (void *udata, void *ptr);
-+typedef void (*duk_fatal_function) (duk_context *ctx, duk_errcode_t code, const char *msg);
-+typedef void (*duk_decode_char_function) (void *udata, duk_codepoint_t codepoint);
-+typedef duk_codepoint_t (*duk_map_char_function) (void *udata, duk_codepoint_t codepoint);
-+typedef duk_ret_t (*duk_safe_call_function) (duk_context *ctx);
-+typedef duk_size_t (*duk_debug_read_function) (void *udata, char *buffer, duk_size_t length);
-+typedef duk_size_t (*duk_debug_write_function) (void *udata, const char *buffer, duk_size_t length);
-+typedef duk_size_t (*duk_debug_peek_function) (void *udata);
-+typedef void (*duk_debug_read_flush_function) (void *udata);
-+typedef void (*duk_debug_write_flush_function) (void *udata);
-+typedef void (*duk_debug_detached_function) (void *udata);
-+
-+struct duk_memory_functions {
-+	duk_alloc_function alloc_func;
-+	duk_realloc_function realloc_func;
-+	duk_free_function free_func;
-+	void *udata;
-+};
-+
-+struct duk_function_list_entry {
-+	const char *key;
-+	duk_c_function value;
-+	duk_idx_t nargs;
-+};
-+
-+struct duk_number_list_entry {
-+	const char *key;
-+	duk_double_t value;
-+};
-+
-+/*
-+ *  Constants
-+ */
-+
-+/* Duktape version, (major * 10000) + (minor * 100) + patch.  Allows C code
-+ * to #ifdef against Duktape API version.  The same value is also available
-+ * to Ecmascript code in Duktape.version.  Unofficial development snapshots
-+ * have 99 for patch level (e.g. 0.10.99 would be a development version
-+ * after 0.10.0 but before the next official release).
-+ */
-+#define DUK_VERSION                       10203L
-+
-+/* Git describe for Duktape build.  Useful for non-official snapshot builds
-+ * so that application code can easily log which Duktape snapshot was used.
-+ * Not available in the Ecmascript environment.
-+ */
-+#define DUK_GIT_DESCRIBE                  "v1.2.3"
-+
-+/* Duktape debug protocol version used by this build. */
-+#define DUK_DEBUG_PROTOCOL_VERSION        1
-+
-+/* Used to represent invalid index; if caller uses this without checking,
-+ * this index will map to a non-existent stack entry.  Also used in some
-+ * API calls as a marker to denote "no value".
-+ */
-+#define DUK_INVALID_INDEX                 DUK_IDX_MIN
-+
-+/* Indicates that a native function does not have a fixed number of args,
-+ * and the argument stack should not be capped/extended at all.
-+ */
-+#define DUK_VARARGS                       ((duk_int_t) (-1))
-+
-+/* Number of value stack entries (in addition to actual call arguments)
-+ * guaranteed to be allocated on entry to a Duktape/C function.
-+ */
-+#define DUK_API_ENTRY_STACK               64
-+
-+/* Value types, used by e.g. duk_get_type() */
-+#define DUK_TYPE_NONE                     0    /* no value, e.g. invalid index */
-+#define DUK_TYPE_UNDEFINED                1    /* Ecmascript undefined */
-+#define DUK_TYPE_NULL                     2    /* Ecmascript null */
-+#define DUK_TYPE_BOOLEAN                  3    /* Ecmascript boolean: 0 or 1 */
-+#define DUK_TYPE_NUMBER                   4    /* Ecmascript number: double */
-+#define DUK_TYPE_STRING                   5    /* Ecmascript string: CESU-8 / extended UTF-8 encoded */
-+#define DUK_TYPE_OBJECT                   6    /* Ecmascript object: includes objects, arrays, functions, threads */
-+#define DUK_TYPE_BUFFER                   7    /* fixed or dynamic, garbage collected byte buffer */
-+#define DUK_TYPE_POINTER                  8    /* raw void pointer */
-+#define DUK_TYPE_LIGHTFUNC                9    /* lightweight function pointer */
-+
-+/* Value mask types, used by e.g. duk_get_type_mask() */
-+#define DUK_TYPE_MASK_NONE                (1 << DUK_TYPE_NONE)
-+#define DUK_TYPE_MASK_UNDEFINED           (1 << DUK_TYPE_UNDEFINED)
-+#define DUK_TYPE_MASK_NULL                (1 << DUK_TYPE_NULL)
-+#define DUK_TYPE_MASK_BOOLEAN             (1 << DUK_TYPE_BOOLEAN)
-+#define DUK_TYPE_MASK_NUMBER              (1 << DUK_TYPE_NUMBER)
-+#define DUK_TYPE_MASK_STRING              (1 << DUK_TYPE_STRING)
-+#define DUK_TYPE_MASK_OBJECT              (1 << DUK_TYPE_OBJECT)
-+#define DUK_TYPE_MASK_BUFFER              (1 << DUK_TYPE_BUFFER)
-+#define DUK_TYPE_MASK_POINTER             (1 << DUK_TYPE_POINTER)
-+#define DUK_TYPE_MASK_LIGHTFUNC           (1 << DUK_TYPE_LIGHTFUNC)
-+#define DUK_TYPE_MASK_THROW               (1 << 10)  /* internal flag value: throw if mask doesn't match */
-+
-+/* Coercion hints */
-+#define DUK_HINT_NONE                     0    /* prefer number, unless input is a Date, in which
-+                                                * case prefer string (E5 Section 8.12.8)
-+                                                */
-+#define DUK_HINT_STRING                   1    /* prefer string */
-+#define DUK_HINT_NUMBER                   2    /* prefer number */
-+
-+/* Enumeration flags for duk_enum() */
-+#define DUK_ENUM_INCLUDE_NONENUMERABLE    (1 << 0)    /* enumerate non-numerable properties in addition to enumerable */
-+#define DUK_ENUM_INCLUDE_INTERNAL         (1 << 1)    /* enumerate internal properties (regardless of enumerability) */
-+#define DUK_ENUM_OWN_PROPERTIES_ONLY      (1 << 2)    /* don't walk prototype chain, only check own properties */
-+#define DUK_ENUM_ARRAY_INDICES_ONLY       (1 << 3)    /* only enumerate array indices */
-+#define DUK_ENUM_SORT_ARRAY_INDICES       (1 << 4)    /* sort array indices, use with DUK_ENUM_ARRAY_INDICES_ONLY */
-+#define DUK_ENUM_NO_PROXY_BEHAVIOR        (1 << 5)    /* enumerate a proxy object itself without invoking proxy behavior */
-+
-+/* Compilation flags for duk_compile() and duk_eval() */
-+#define DUK_COMPILE_EVAL                  (1 << 0)    /* compile eval code (instead of program) */
-+#define DUK_COMPILE_FUNCTION              (1 << 1)    /* compile function code (instead of program) */
-+#define DUK_COMPILE_STRICT                (1 << 2)    /* use strict (outer) context for program, eval, or function */
-+#define DUK_COMPILE_SAFE                  (1 << 3)    /* (internal) catch compilation errors */
-+#define DUK_COMPILE_NORESULT              (1 << 4)    /* (internal) omit eval result */
-+#define DUK_COMPILE_NOSOURCE              (1 << 5)    /* (internal) no source string on stack */
-+#define DUK_COMPILE_STRLEN                (1 << 6)    /* (internal) take strlen() of src_buffer (avoids double evaluation in macro) */
-+
-+/* Flags for duk_def_prop() and its variants */
-+#define DUK_DEFPROP_WRITABLE              (1 << 0)    /* set writable (effective if DUK_DEFPROP_HAVE_WRITABLE set) */
-+#define DUK_DEFPROP_ENUMERABLE            (1 << 1)    /* set enumerable (effective if DUK_DEFPROP_HAVE_ENUMERABLE set) */
-+#define DUK_DEFPROP_CONFIGURABLE          (1 << 2)    /* set configurable (effective if DUK_DEFPROP_HAVE_CONFIGURABLE set) */
-+#define DUK_DEFPROP_HAVE_WRITABLE         (1 << 3)    /* set/clear writable */
-+#define DUK_DEFPROP_HAVE_ENUMERABLE       (1 << 4)    /* set/clear enumerable */
-+#define DUK_DEFPROP_HAVE_CONFIGURABLE     (1 << 5)    /* set/clear configurable */
-+#define DUK_DEFPROP_HAVE_VALUE            (1 << 6)    /* set value (given on value stack) */
-+#define DUK_DEFPROP_HAVE_GETTER           (1 << 7)    /* set getter (given on value stack) */
-+#define DUK_DEFPROP_HAVE_SETTER           (1 << 8)    /* set setter (given on value stack) */
-+#define DUK_DEFPROP_FORCE                 (1 << 9)    /* force change if possible, may still fail for e.g. virtual properties */
-+
-+/* Flags for duk_push_thread_raw() */
-+#define DUK_THREAD_NEW_GLOBAL_ENV         (1 << 0)    /* create a new global environment */
-+
-+/* Flags for duk_push_string_file_raw() */
-+#define DUK_STRING_PUSH_SAFE              (1 << 0)    /* no error if file does not exist */
-+
-+/* Duktape specific error codes */
-+#define DUK_ERR_NONE                      0    /* no error (e.g. from duk_get_error_code()) */
-+#define DUK_ERR_UNIMPLEMENTED_ERROR       50   /* UnimplementedError */
-+#define DUK_ERR_UNSUPPORTED_ERROR         51   /* UnsupportedError */
-+#define DUK_ERR_INTERNAL_ERROR            52   /* InternalError */
-+#define DUK_ERR_ALLOC_ERROR               53   /* AllocError */
-+#define DUK_ERR_ASSERTION_ERROR           54   /* AssertionError */
-+#define DUK_ERR_API_ERROR                 55   /* APIError */
-+#define DUK_ERR_UNCAUGHT_ERROR            56   /* UncaughtError */
-+
-+/* Ecmascript E5 specification error codes */
-+#define DUK_ERR_ERROR                     100  /* Error */
-+#define DUK_ERR_EVAL_ERROR                101  /* EvalError */
-+#define DUK_ERR_RANGE_ERROR               102  /* RangeError */
-+#define DUK_ERR_REFERENCE_ERROR           103  /* ReferenceError */
-+#define DUK_ERR_SYNTAX_ERROR              104  /* SyntaxError */
-+#define DUK_ERR_TYPE_ERROR                105  /* TypeError */
-+#define DUK_ERR_URI_ERROR                 106  /* URIError */
-+
-+/* Return codes for C functions (shortcut for throwing an error) */
-+#define DUK_RET_UNIMPLEMENTED_ERROR       (-DUK_ERR_UNIMPLEMENTED_ERROR)
-+#define DUK_RET_UNSUPPORTED_ERROR         (-DUK_ERR_UNSUPPORTED_ERROR)
-+#define DUK_RET_INTERNAL_ERROR            (-DUK_ERR_INTERNAL_ERROR)
-+#define DUK_RET_ALLOC_ERROR               (-DUK_ERR_ALLOC_ERROR)
-+#define DUK_RET_ASSERTION_ERROR           (-DUK_ERR_ASSERTION_ERROR)
-+#define DUK_RET_API_ERROR                 (-DUK_ERR_API_ERROR)
-+#define DUK_RET_UNCAUGHT_ERROR            (-DUK_ERR_UNCAUGHT_ERROR)
-+#define DUK_RET_ERROR                     (-DUK_ERR_ERROR)
-+#define DUK_RET_EVAL_ERROR                (-DUK_ERR_EVAL_ERROR)
-+#define DUK_RET_RANGE_ERROR               (-DUK_ERR_RANGE_ERROR)
-+#define DUK_RET_REFERENCE_ERROR           (-DUK_ERR_REFERENCE_ERROR)
-+#define DUK_RET_SYNTAX_ERROR              (-DUK_ERR_SYNTAX_ERROR)
-+#define DUK_RET_TYPE_ERROR                (-DUK_ERR_TYPE_ERROR)
-+#define DUK_RET_URI_ERROR                 (-DUK_ERR_URI_ERROR)
-+
-+/* Return codes for protected calls (duk_safe_call(), duk_pcall()). */
-+#define DUK_EXEC_SUCCESS                  0
-+#define DUK_EXEC_ERROR                    1
-+
-+/* Log levels */
-+#define DUK_LOG_TRACE                     0
-+#define DUK_LOG_DEBUG                     1
-+#define DUK_LOG_INFO                      2
-+#define DUK_LOG_WARN                      3
-+#define DUK_LOG_ERROR                     4
-+#define DUK_LOG_FATAL                     5
-+
-+/*
-+ *  If no variadic macros, __FILE__ and __LINE__ are passed through globals
-+ *  which is ugly and not thread safe.
-+ */
-+
-+#ifndef DUK_API_VARIADIC_MACROS
-+DUK_EXTERNAL_DECL const char *duk_api_global_filename;
-+DUK_EXTERNAL_DECL duk_int_t duk_api_global_line;
-+#endif
-+
-+/*
-+ *  Context management
-+ */
-+
-+DUK_EXTERNAL_DECL
-+duk_context *duk_create_heap(duk_alloc_function alloc_func,
-+                             duk_realloc_function realloc_func,
-+                             duk_free_function free_func,
-+                             void *heap_udata,
-+                             duk_fatal_function fatal_handler);
-+DUK_EXTERNAL_DECL void duk_destroy_heap(duk_context *ctx);
-+
-+#define duk_create_heap_default() \
-+	duk_create_heap(NULL, NULL, NULL, NULL, NULL)
-+
-+/*
-+ *  Memory management
-+ *
-+ *  Raw functions have no side effects (cannot trigger GC).
-+ */
-+
-+DUK_EXTERNAL_DECL void *duk_alloc_raw(duk_context *ctx, duk_size_t size);
-+DUK_EXTERNAL_DECL void duk_free_raw(duk_context *ctx, void *ptr);
-+DUK_EXTERNAL_DECL void *duk_realloc_raw(duk_context *ctx, void *ptr, duk_size_t size);
-+DUK_EXTERNAL_DECL void *duk_alloc(duk_context *ctx, duk_size_t size);
-+DUK_EXTERNAL_DECL void duk_free(duk_context *ctx, void *ptr);
-+DUK_EXTERNAL_DECL void *duk_realloc(duk_context *ctx, void *ptr, duk_size_t size);
-+DUK_EXTERNAL_DECL void duk_get_memory_functions(duk_context *ctx, duk_memory_functions *out_funcs);
-+DUK_EXTERNAL_DECL void duk_gc(duk_context *ctx, duk_uint_t flags);
-+
-+/*
-+ *  Error handling
-+ */
-+
-+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_throw(duk_context *ctx));
-+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_fatal(duk_context *ctx, duk_errcode_t err_code, const char *err_msg));
-+
-+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...));
-+
-+#ifdef DUK_API_VARIADIC_MACROS
-+#define duk_error(ctx,err_code,...)  \
-+	duk_error_raw((ctx), (duk_errcode_t) (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), __VA_ARGS__)
-+#else
-+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...));
-+/* One problem with this macro is that expressions like the following fail
-+ * to compile: "(void) duk_error(...)".  But because duk_error() is noreturn,
-+ * they make little sense anyway.
-+ */
-+#define duk_error  \
-+	(duk_api_global_filename = (const char *) (__FILE__), \
-+	 duk_api_global_line = (duk_int_t) (__LINE__), \
-+	 duk_error_stash)  /* last value is func pointer, arguments follow in parens */
-+#endif
-+
-+DUK_API_NORETURN(DUK_EXTERNAL_DECL void duk_error_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap));
-+#define duk_error_va(ctx,err_code,fmt,ap)  \
-+	duk_error_va_raw((ctx), (duk_errcode_t) (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), (fmt), (ap))
-+
-+/*
-+ *  Other state related functions
-+ */
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_strict_call(duk_context *ctx);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_constructor_call(duk_context *ctx);
-+
-+/*
-+ *  Stack management
-+ */
-+
-+DUK_EXTERNAL_DECL duk_idx_t duk_normalize_index(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_idx_t duk_require_normalize_index(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_valid_index(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_require_valid_index(duk_context *ctx, duk_idx_t index);
-+
-+DUK_EXTERNAL_DECL duk_idx_t duk_get_top(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_set_top(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_idx_t duk_get_top_index(duk_context *ctx);
-+DUK_EXTERNAL_DECL duk_idx_t duk_require_top_index(duk_context *ctx);
-+
-+/* Although extra/top could be an unsigned type here, using a signed type
-+ * makes the API more robust to calling code calculation errors or corner
-+ * cases (where caller might occasionally come up with negative values).
-+ * Negative values are treated as zero, which is better than casting them
-+ * to a large unsigned number.  (This principle is used elsewhere in the
-+ * API too.)
-+ */
-+DUK_EXTERNAL_DECL duk_bool_t duk_check_stack(duk_context *ctx, duk_idx_t extra);
-+DUK_EXTERNAL_DECL void duk_require_stack(duk_context *ctx, duk_idx_t extra);
-+DUK_EXTERNAL_DECL duk_bool_t duk_check_stack_top(duk_context *ctx, duk_idx_t top);
-+DUK_EXTERNAL_DECL void duk_require_stack_top(duk_context *ctx, duk_idx_t top);
-+
-+/*
-+ *  Stack manipulation (other than push/pop)
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_swap(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
-+DUK_EXTERNAL_DECL void duk_swap_top(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_dup(duk_context *ctx, duk_idx_t from_index);
-+DUK_EXTERNAL_DECL void duk_dup_top(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_insert(duk_context *ctx, duk_idx_t to_index);
-+DUK_EXTERNAL_DECL void duk_replace(duk_context *ctx, duk_idx_t to_index);
-+DUK_EXTERNAL_DECL void duk_copy(duk_context *ctx, duk_idx_t from_index, duk_idx_t to_index);
-+DUK_EXTERNAL_DECL void duk_remove(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_xcopymove_raw(duk_context *to_ctx, duk_context *from_ctx, duk_idx_t count, duk_bool_t is_copy);
-+
-+#define duk_xmove_top(to_ctx,from_ctx,count) \
-+	duk_xcopymove_raw((to_ctx), (from_ctx), (count), 0 /*is_copy*/)
-+#define duk_xcopy_top(to_ctx,from_ctx,count) \
-+	duk_xcopymove_raw((to_ctx), (from_ctx), (count), 1 /*is_copy*/)
-+
-+/*
-+ *  Push operations
-+ *
-+ *  Push functions return the absolute (relative to bottom of frame)
-+ *  position of the pushed value for convenience.
-+ *
-+ *  Note: duk_dup() is technically a push.
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_push_undefined(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_null(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_boolean(duk_context *ctx, duk_bool_t val);
-+DUK_EXTERNAL_DECL void duk_push_true(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_false(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_number(duk_context *ctx, duk_double_t val);
-+DUK_EXTERNAL_DECL void duk_push_nan(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_int(duk_context *ctx, duk_int_t val);
-+DUK_EXTERNAL_DECL void duk_push_uint(duk_context *ctx, duk_uint_t val);
-+DUK_EXTERNAL_DECL const char *duk_push_string(duk_context *ctx, const char *str);
-+DUK_EXTERNAL_DECL const char *duk_push_lstring(duk_context *ctx, const char *str, duk_size_t len);
-+DUK_EXTERNAL_DECL void duk_push_pointer(duk_context *ctx, void *p);
-+DUK_EXTERNAL_DECL const char *duk_push_sprintf(duk_context *ctx, const char *fmt, ...);
-+DUK_EXTERNAL_DECL const char *duk_push_vsprintf(duk_context *ctx, const char *fmt, va_list ap);
-+
-+DUK_EXTERNAL_DECL const char *duk_push_string_file_raw(duk_context *ctx, const char *path, duk_uint_t flags);
-+#define duk_push_string_file(ctx,path) \
-+	duk_push_string_file_raw((ctx), (path), 0)
-+
-+DUK_EXTERNAL_DECL void duk_push_this(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_current_function(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_current_thread(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_global_object(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_heap_stash(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_global_stash(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_push_thread_stash(duk_context *ctx, duk_context *target_ctx);
-+
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_object(duk_context *ctx);
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_array(duk_context *ctx);
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_c_function(duk_context *ctx, duk_c_function func, duk_idx_t nargs);
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_c_lightfunc(duk_context *ctx, duk_c_function func, duk_idx_t nargs, duk_idx_t length, duk_int_t magic);
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_thread_raw(duk_context *ctx, duk_uint_t flags);
-+
-+#define duk_push_thread(ctx) \
-+	duk_push_thread_raw((ctx), 0 /*flags*/)
-+
-+#define duk_push_thread_new_globalenv(ctx) \
-+	duk_push_thread_raw((ctx), DUK_THREAD_NEW_GLOBAL_ENV /*flags*/)
-+
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, ...);
-+
-+#ifdef DUK_API_VARIADIC_MACROS
-+#define duk_push_error_object(ctx,err_code,...)  \
-+	duk_push_error_object_raw((ctx), (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), __VA_ARGS__)
-+#else
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_stash(duk_context *ctx, duk_errcode_t err_code, const char *fmt, ...);
-+/* Note: parentheses are required so that the comma expression works in assignments. */
-+#define duk_push_error_object  \
-+	(duk_api_global_filename = (const char *) (__FILE__), \
-+	 duk_api_global_line = (duk_int_t) (__LINE__), \
-+	 duk_push_error_object_stash)  /* last value is func pointer, arguments follow in parens */
-+#endif
-+
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_error_object_va_raw(duk_context *ctx, duk_errcode_t err_code, const char *filename, duk_int_t line, const char *fmt, va_list ap);
-+#define duk_push_error_object_va(ctx,err_code,fmt,ap)  \
-+	duk_push_error_object_va_raw((ctx), (err_code), (const char *) (__FILE__), (duk_int_t) (__LINE__), (fmt), (ap))
-+
-+#define DUK_BUF_FLAG_DYNAMIC   (1 << 0)    /* internal flag: dynamic buffer */
-+#define DUK_BUF_FLAG_NOZERO    (1 << 1)    /* internal flag: don't zero allocated buffer */
-+
-+DUK_EXTERNAL_DECL void *duk_push_buffer_raw(duk_context *ctx, duk_size_t size, duk_small_uint_t flags);
-+
-+#define duk_push_buffer(ctx,size,dynamic) \
-+	duk_push_buffer_raw((ctx), (size), (dynamic));
-+#define duk_push_fixed_buffer(ctx,size) \
-+	duk_push_buffer_raw((ctx), (size), 0 /*dynamic*/)
-+#define duk_push_dynamic_buffer(ctx,size) \
-+	duk_push_buffer_raw((ctx), (size), 1 /*dynamic*/)
-+
-+DUK_EXTERNAL_DECL duk_idx_t duk_push_heapptr(duk_context *ctx, void *ptr);
-+
-+/*
-+ *  Pop operations
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_pop(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_pop_n(duk_context *ctx, duk_idx_t count);
-+DUK_EXTERNAL_DECL void duk_pop_2(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_pop_3(duk_context *ctx);
-+
-+/*
-+ *  Type checks
-+ *
-+ *  duk_is_none(), which would indicate whether index it outside of stack,
-+ *  is not needed; duk_is_valid_index() gives the same information.
-+ */
-+
-+DUK_EXTERNAL_DECL duk_int_t duk_get_type(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_check_type(duk_context *ctx, duk_idx_t index, duk_int_t type);
-+DUK_EXTERNAL_DECL duk_uint_t duk_get_type_mask(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_check_type_mask(duk_context *ctx, duk_idx_t index, duk_uint_t mask);
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_undefined(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_null(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_null_or_undefined(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_boolean(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_number(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_nan(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_string(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_object(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_buffer(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_pointer(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_lightfunc(duk_context *ctx, duk_idx_t index);
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_array(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_function(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_c_function(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_ecmascript_function(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_bound_function(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_thread(duk_context *ctx, duk_idx_t index);
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_callable(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_dynamic_buffer(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_fixed_buffer(duk_context *ctx, duk_idx_t index);
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_is_primitive(duk_context *ctx, duk_idx_t index);
-+#define duk_is_object_coercible(ctx,index) \
-+	duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
-+	                                    DUK_TYPE_MASK_NUMBER | \
-+	                                    DUK_TYPE_MASK_STRING | \
-+	                                    DUK_TYPE_MASK_OBJECT | \
-+	                                    DUK_TYPE_MASK_BUFFER | \
-+	                                    DUK_TYPE_MASK_POINTER | \
-+	                                    DUK_TYPE_MASK_LIGHTFUNC)
-+
-+DUK_EXTERNAL_DECL duk_errcode_t duk_get_error_code(duk_context *ctx, duk_idx_t index);
-+#define duk_is_error(ctx,index) \
-+	(duk_get_error_code((ctx), (index)) != 0)
-+
-+/*
-+ *  Get operations: no coercion, returns default value for invalid
-+ *  indices and invalid value types.
-+ *
-+ *  duk_get_undefined() and duk_get_null() would be pointless and
-+ *  are not included.
-+ */
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_get_boolean(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_double_t duk_get_number(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_int_t duk_get_int(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_uint_t duk_get_uint(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL const char *duk_get_string(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL const char *duk_get_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
-+DUK_EXTERNAL_DECL void *duk_get_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
-+DUK_EXTERNAL_DECL void *duk_get_pointer(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_c_function duk_get_c_function(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_context *duk_get_context(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void *duk_get_heapptr(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_size_t duk_get_length(duk_context *ctx, duk_idx_t index);
-+
-+/*
-+ *  Require operations: no coercion, throw error if index or type
-+ *  is incorrect.  No defaulting.
-+ */
-+
-+#define duk_require_type_mask(ctx,index,mask) \
-+	((void) duk_check_type_mask((ctx), (index), (mask) | DUK_TYPE_MASK_THROW))
-+
-+DUK_EXTERNAL_DECL void duk_require_undefined(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_require_null(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_require_boolean(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_double_t duk_require_number(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_int_t duk_require_int(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_uint_t duk_require_uint(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL const char *duk_require_string(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL const char *duk_require_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
-+DUK_EXTERNAL_DECL void *duk_require_buffer(duk_context *ctx, duk_idx_t index, duk_size_t *out_size);
-+DUK_EXTERNAL_DECL void *duk_require_pointer(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_c_function duk_require_c_function(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_context *duk_require_context(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void *duk_require_heapptr(duk_context *ctx, duk_idx_t index);
-+
-+#define duk_require_object_coercible(ctx,index) \
-+	((void) duk_check_type_mask((ctx), (index), DUK_TYPE_MASK_BOOLEAN | \
-+	                                            DUK_TYPE_MASK_NUMBER | \
-+	                                            DUK_TYPE_MASK_STRING | \
-+	                                            DUK_TYPE_MASK_OBJECT | \
-+	                                            DUK_TYPE_MASK_BUFFER | \
-+	                                            DUK_TYPE_MASK_POINTER | \
-+	                                            DUK_TYPE_MASK_LIGHTFUNC | \
-+	                                            DUK_TYPE_MASK_THROW))
-+
-+/*
-+ *  Coercion operations: in-place coercion, return coerced value where
-+ *  applicable.  If index is invalid, throw error.  Some coercions may
-+ *  throw an expected error (e.g. from a toString() or valueOf() call)
-+ *  or an internal error (e.g. from out of memory).
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_to_undefined(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_to_null(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_to_boolean(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_double_t duk_to_number(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_int_t duk_to_int(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_uint_t duk_to_uint(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_int32_t duk_to_int32(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_uint32_t duk_to_uint32(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_uint16_t duk_to_uint16(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL const char *duk_to_string(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL const char *duk_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
-+DUK_EXTERNAL_DECL void *duk_to_buffer_raw(duk_context *ctx, duk_idx_t index, duk_size_t *out_size, duk_uint_t flags);
-+DUK_EXTERNAL_DECL void *duk_to_pointer(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_to_object(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_to_defaultvalue(duk_context *ctx, duk_idx_t index, duk_int_t hint);
-+DUK_EXTERNAL_DECL void duk_to_primitive(duk_context *ctx, duk_idx_t index, duk_int_t hint);
-+
-+#define DUK_BUF_MODE_FIXED      0   /* internal: request fixed buffer result */
-+#define DUK_BUF_MODE_DYNAMIC    1   /* internal: request dynamic buffer result */
-+#define DUK_BUF_MODE_DONTCARE   2   /* internal: don't care about fixed/dynamic nature */
-+
-+#define duk_to_buffer(ctx,index,out_size) \
-+	duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DONTCARE)
-+#define duk_to_fixed_buffer(ctx,index,out_size) \
-+	duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_FIXED)
-+#define duk_to_dynamic_buffer(ctx,index,out_size) \
-+	duk_to_buffer_raw((ctx), (index), (out_size), DUK_BUF_MODE_DYNAMIC)
-+
-+/* safe variants of a few coercion operations */
-+DUK_EXTERNAL_DECL const char *duk_safe_to_lstring(duk_context *ctx, duk_idx_t index, duk_size_t *out_len);
-+#define duk_safe_to_string(ctx,index) \
-+	duk_safe_to_lstring((ctx), (index), NULL)
-+
-+/*
-+ *  Misc conversion
-+ */
-+
-+DUK_EXTERNAL_DECL const char *duk_base64_encode(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_base64_decode(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL const char *duk_hex_encode(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_hex_decode(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL const char *duk_json_encode(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_json_decode(duk_context *ctx, duk_idx_t index);
-+
-+/*
-+ *  Buffer
-+ */
-+
-+DUK_EXTERNAL_DECL void *duk_resize_buffer(duk_context *ctx, duk_idx_t index, duk_size_t new_size);
-+
-+/*
-+ *  Property access
-+ *
-+ *  The basic function assumes key is on stack.  The _string variant takes
-+ *  a C string as a property name, while the _index variant takes an array
-+ *  index as a property name (e.g. 123 is equivalent to the key "123").
-+ */
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop(duk_context *ctx, duk_idx_t obj_index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
-+DUK_EXTERNAL_DECL duk_bool_t duk_get_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop(duk_context *ctx, duk_idx_t obj_index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
-+DUK_EXTERNAL_DECL duk_bool_t duk_put_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop(duk_context *ctx, duk_idx_t obj_index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
-+DUK_EXTERNAL_DECL duk_bool_t duk_del_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop(duk_context *ctx, duk_idx_t obj_index);
-+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_string(duk_context *ctx, duk_idx_t obj_index, const char *key);
-+DUK_EXTERNAL_DECL duk_bool_t duk_has_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index);
-+DUK_EXTERNAL_DECL void duk_def_prop(duk_context *ctx, duk_idx_t obj_index, duk_uint_t flags);
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_get_global_string(duk_context *ctx, const char *key);
-+DUK_EXTERNAL_DECL duk_bool_t duk_put_global_string(duk_context *ctx, const char *key);
-+
-+/*
-+ *  Object prototype
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_get_prototype(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_set_prototype(duk_context *ctx, duk_idx_t index);
-+
-+/*
-+ *  Object finalizer
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_get_finalizer(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_set_finalizer(duk_context *ctx, duk_idx_t index);
-+
-+/*
-+ *  Global object
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_set_global_object(duk_context *ctx);
-+
-+/*
-+ *  Duktape/C function magic value
-+ */
-+
-+DUK_EXTERNAL_DECL duk_int_t duk_get_magic(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL void duk_set_magic(duk_context *ctx, duk_idx_t index, duk_int_t magic);
-+DUK_EXTERNAL_DECL duk_int_t duk_get_current_magic(duk_context *ctx);
-+
-+/*
-+ *  Module helpers: put multiple function or constant properties
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_put_function_list(duk_context *ctx, duk_idx_t obj_index, const duk_function_list_entry *funcs);
-+DUK_EXTERNAL_DECL void duk_put_number_list(duk_context *ctx, duk_idx_t obj_index, const duk_number_list_entry *numbers);
-+
-+/*
-+ *  Variable access
-+ */
-+
-+/* XXX: These calls are incomplete and not usable now.  They are not (yet)
-+ * part of the public API.
-+ */
-+DUK_EXTERNAL_DECL void duk_get_var(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_put_var(duk_context *ctx);
-+DUK_EXTERNAL_DECL duk_bool_t duk_del_var(duk_context *ctx);
-+DUK_EXTERNAL_DECL duk_bool_t duk_has_var(duk_context *ctx);
-+
-+/*
-+ *  Object operations
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_compact(duk_context *ctx, duk_idx_t obj_index);
-+DUK_EXTERNAL_DECL void duk_enum(duk_context *ctx, duk_idx_t obj_index, duk_uint_t enum_flags);
-+DUK_EXTERNAL_DECL duk_bool_t duk_next(duk_context *ctx, duk_idx_t enum_index, duk_bool_t get_value);
-+
-+/*
-+ *  String manipulation
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_concat(duk_context *ctx, duk_idx_t count);
-+DUK_EXTERNAL_DECL void duk_join(duk_context *ctx, duk_idx_t count);
-+DUK_EXTERNAL_DECL void duk_decode_string(duk_context *ctx, duk_idx_t index, duk_decode_char_function callback, void *udata);
-+DUK_EXTERNAL_DECL void duk_map_string(duk_context *ctx, duk_idx_t index, duk_map_char_function callback, void *udata);
-+DUK_EXTERNAL_DECL void duk_substring(duk_context *ctx, duk_idx_t index, duk_size_t start_char_offset, duk_size_t end_char_offset);
-+DUK_EXTERNAL_DECL void duk_trim(duk_context *ctx, duk_idx_t index);
-+DUK_EXTERNAL_DECL duk_codepoint_t duk_char_code_at(duk_context *ctx, duk_idx_t index, duk_size_t char_offset);
-+
-+/*
-+ *  Ecmascript operators
-+ */
-+
-+DUK_EXTERNAL_DECL duk_bool_t duk_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
-+DUK_EXTERNAL_DECL duk_bool_t duk_strict_equals(duk_context *ctx, duk_idx_t index1, duk_idx_t index2);
-+
-+/*
-+ *  Function (method) calls
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_call(duk_context *ctx, duk_idx_t nargs);
-+DUK_EXTERNAL_DECL void duk_call_method(duk_context *ctx, duk_idx_t nargs);
-+DUK_EXTERNAL_DECL void duk_call_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs);
-+DUK_EXTERNAL_DECL duk_int_t duk_pcall(duk_context *ctx, duk_idx_t nargs);
-+DUK_EXTERNAL_DECL duk_int_t duk_pcall_method(duk_context *ctx, duk_idx_t nargs);
-+DUK_EXTERNAL_DECL duk_int_t duk_pcall_prop(duk_context *ctx, duk_idx_t obj_index, duk_idx_t nargs);
-+DUK_EXTERNAL_DECL void duk_new(duk_context *ctx, duk_idx_t nargs);
-+DUK_EXTERNAL_DECL duk_int_t duk_safe_call(duk_context *ctx, duk_safe_call_function func, duk_idx_t nargs, duk_idx_t nrets);
-+
-+/*
-+ *  Thread management
-+ */
-+
-+/* There are currently no native functions to yield/resume, due to the internal
-+ * limitations on coroutine handling.  These will be added later.
-+ */
-+
-+/*
-+ *  Compilation and evaluation
-+ */
-+
-+DUK_EXTERNAL_DECL duk_int_t duk_eval_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags);
-+DUK_EXTERNAL_DECL duk_int_t duk_compile_raw(duk_context *ctx, const char *src_buffer, duk_size_t src_length, duk_uint_t flags);
-+
-+/* plain */
-+#define duk_eval(ctx)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL))
-+
-+#define duk_eval_noresult(ctx)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT))
-+
-+#define duk_peval(ctx)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE))
-+
-+#define duk_peval_noresult(ctx)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT))
-+
-+#define duk_compile(ctx,flags)  \
-+	((void) duk_compile_raw((ctx), NULL, 0, (flags)))
-+
-+#define duk_pcompile(ctx,flags)  \
-+	(duk_compile_raw((ctx), NULL, 0, (flags) | DUK_COMPILE_SAFE))
-+
-+/* string */
-+#define duk_eval_string(ctx,src)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 (void) duk_eval_raw((ctx), (src), 0, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
-+
-+#define duk_eval_string_noresult(ctx,src)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 (void) duk_eval_raw((ctx), (src), 0, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT))
-+
-+#define duk_peval_string(ctx,src)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 duk_eval_raw((ctx), (src), 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
-+
-+#define duk_peval_string_noresult(ctx,src)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 duk_eval_raw((ctx), (src), 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN | DUK_COMPILE_NORESULT))
-+
-+#define duk_compile_string(ctx,flags,src)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 (void) duk_compile_raw((ctx), (src), 0, (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
-+
-+#define duk_compile_string_filename(ctx,flags,src)  \
-+	((void) duk_compile_raw((ctx), (src), 0, (flags) | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
-+
-+#define duk_pcompile_string(ctx,flags,src)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 duk_compile_raw((ctx), (src), 0, (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
-+
-+#define duk_pcompile_string_filename(ctx,flags,src)  \
-+	(duk_compile_raw((ctx), (src), 0, (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_STRLEN))
-+
-+/* lstring */
-+#define duk_eval_lstring(ctx,buf,len)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 (void) duk_eval_raw((ctx), buf, len, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE))
-+
-+#define duk_eval_lstring_noresult(ctx,buf,len)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 (void) duk_eval_raw((ctx), buf, len, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT))
-+
-+#define duk_peval_lstring(ctx,buf,len)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 duk_eval_raw((ctx), buf, len, DUK_COMPILE_EVAL | DUK_COMPILE_NOSOURCE | DUK_COMPILE_SAFE))
-+
-+#define duk_peval_lstring_noresult(ctx,buf,len)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 duk_eval_raw((ctx), buf, len, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE | DUK_COMPILE_NORESULT))
-+
-+#define duk_compile_lstring(ctx,flags,buf,len)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 (void) duk_compile_raw((ctx), buf, len, (flags) | DUK_COMPILE_NOSOURCE))
-+
-+#define duk_compile_lstring_filename(ctx,flags,buf,len)  \
-+	((void) duk_compile_raw((ctx), buf, len, (flags) | DUK_COMPILE_NOSOURCE))
-+
-+#define duk_pcompile_lstring(ctx,flags,buf,len)  \
-+	((void) duk_push_string((ctx), (const char *) (__FILE__)), \
-+	 duk_compile_raw((ctx), buf, len, (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE))
-+
-+#define duk_pcompile_lstring_filename(ctx,flags,buf,len)  \
-+	(duk_compile_raw((ctx), buf, len, (flags) | DUK_COMPILE_SAFE | DUK_COMPILE_NOSOURCE))
-+
-+/* file */
-+#define duk_eval_file(ctx,path)  \
-+	((void) duk_push_string_file_raw((ctx), (path), 0), \
-+	 (void) duk_push_string((ctx), (path)), \
-+	 (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL))
-+
-+#define duk_eval_file_noresult(ctx,path)  \
-+	((void) duk_push_string_file_raw((ctx), (path), 0), \
-+	 (void) duk_push_string((ctx), (path)), \
-+	 (void) duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_NORESULT))
-+
-+#define duk_peval_file(ctx,path)  \
-+	((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
-+	 (void) duk_push_string((ctx), (path)), \
-+	 duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE))
-+
-+#define duk_peval_file_noresult(ctx,path)  \
-+	((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
-+	 (void) duk_push_string((ctx), (path)), \
-+	 duk_eval_raw((ctx), NULL, 0, DUK_COMPILE_EVAL | DUK_COMPILE_SAFE | DUK_COMPILE_NORESULT))
-+
-+#define duk_compile_file(ctx,flags,path)  \
-+	((void) duk_push_string_file_raw((ctx), (path), 0), \
-+	 (void) duk_push_string((ctx), (path)), \
-+	 (void) duk_compile_raw((ctx), NULL, 0, (flags)))
-+
-+#define duk_pcompile_file(ctx,flags,path)  \
-+	((void) duk_push_string_file_raw((ctx), (path), DUK_STRING_PUSH_SAFE), \
-+	 (void) duk_push_string((ctx), (path)), \
-+	 duk_compile_raw((ctx), NULL, 0, (flags) | DUK_COMPILE_SAFE))
-+
-+/*
-+ *  Logging
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...);
-+DUK_EXTERNAL_DECL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, va_list ap);
-+
-+/*
-+ *  Debugging
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_push_context_dump(duk_context *ctx);
-+
-+#if defined(DUK_USE_FILE_IO)
-+/* internal use */
-+#define duk_dump_context_filehandle(ctx,fh) \
-+	(duk_push_context_dump((ctx)), \
-+	 DUK_FPRINTF((fh), "%s\n", duk_safe_to_string(ctx, -1)), \
-+	 duk_pop(ctx))
-+
-+/* external use */
-+#define duk_dump_context_stdout(ctx) \
-+	duk_dump_context_filehandle((ctx), DUK_STDOUT)
-+#define duk_dump_context_stderr(ctx) \
-+	duk_dump_context_filehandle((ctx), DUK_STDERR)
-+#else  /* DUK_USE_FILE_IO */
-+#define duk_dump_context_stdout(ctx)  ((void) 0)
-+#define duk_dump_context_stderr(ctx)  ((void) 0)
-+#endif  /* DUK_USE_FILE_IO */
-+
-+/*
-+ *  Debugger (debug protocol)
-+ */
-+
-+DUK_EXTERNAL_DECL void duk_debugger_attach(duk_context *ctx,
-+                                           duk_debug_read_function read_cb,
-+                                           duk_debug_write_function write_cb,
-+                                           duk_debug_peek_function peek_cb,
-+                                           duk_debug_read_flush_function read_flush_cb,
-+                                           duk_debug_write_flush_function write_flush_cb,
-+                                           duk_debug_detached_function detached_cb,
-+                                           void *udata);
-+DUK_EXTERNAL_DECL void duk_debugger_detach(duk_context *ctx);
-+DUK_EXTERNAL_DECL void duk_debugger_cooperate(duk_context *ctx);
-+
-+/*
-+ *  C++ name mangling
-+ */
-+
-+#ifdef __cplusplus
-+/* end 'extern "C"' wrapper */
-+}
-+#endif
-+
-+#endif  /* DUK_API_PUBLIC_H_INCLUDED */
-+
-+/*
-+ *  END PUBLIC API
-+ */
-+
-+/*
-+ *  Sanity check for the final effective internal defines.  This file also
-+ *  double checks user tweaks made by an optional duk_custom.h header.
-+ */
-+
-+#ifndef DUK_FEATURES_SANITY_H_INCLUDED
-+#define DUK_FEATURES_SANITY_H_INCLUDED
-+
-+/*
-+ *  Deprecated feature options.
-+ *
-+ *  Catch so that user more easily notices and updates build.
-+ */
-+
-+#if defined(DUK_OPT_NO_FUNC_STMT)
-+#error DUK_OPT_NO_FUNC_STMT is deprecated, use DUK_OPT_NO_NONSTD_FUNC_STMT
-+#endif
-+
-+#if defined(DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY)
-+#error DUK_OPT_FUNC_NONSTD_CALLER_PROPERTY is deprecated, use DUK_OPT_NONSTD_FUNC_CALLER_PROPERTY
-+#endif
-+
-+#if defined(DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY)
-+#error DUK_OPT_FUNC_NONSTD_SOURCE_PROPERTY is deprecated, use DUK_OPT_NONSTD_FUNC_SOURCE_PROPERTY
-+#endif
-+
-+#if defined(DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT)
-+#error DUK_OPT_NO_ARRAY_SPLICE_NONSTD_DELCOUNT is deprecated, use DUK_OPT_NO_NONSTD_ARRAY_SPLICE_DELCOUNT
-+#endif
-+
-+#if defined(DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY)
-+#error DUK_OPT_NO_OBJECT_ES6_PROTO_PROPERTY is deprecated, use DUK_OPT_NO_ES6_OBJECT_PROTO_PROPERTY
-+#endif
-+
-+#if defined(DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF)
-+#error DUK_OPT_NO_OBJECT_ES6_SETPROTOTYPEOF is deprecated, use DUK_OPT_NO_ES6_OBJECT_SETPROTOTYPEOF
-+#endif
-+
-+#if defined(DUK_OPT_NO_JSONX)
-+#error DUK_OPT_NO_JSONX is deprecated, use DUK_OPT_NO_JX
-+#endif
-+
-+#if defined(DUK_OPT_NO_JSONC)
-+#error DUK_OPT_NO_JSONC is deprecated, use DUK_OPT_NO_JC
-+#endif
-+
-+/*
-+ *  Debug print consistency
-+ */
-+
-+#if defined(DUK_USE_DPRINT) && !defined(DUK_USE_DEBUG)
-+#error DUK_USE_DPRINT without DUK_USE_DEBUG
-+#endif
-+
-+#if defined(DUK_USE_DDPRINT) && !defined(DUK_USE_DEBUG)
-+#error DUK_USE_DDPRINT without DUK_USE_DEBUG
-+#endif
-+
-+#if defined(DUK_USE_DDDPRINT) && !defined(DUK_USE_DEBUG)
-+#error DUK_USE_DDDPRINT without DUK_USE_DEBUG
-+#endif
-+
-+#if defined(DUK_USE_HEAPPTR16) && defined(DUK_USE_DEBUG)
-+/* Debug code doesn't have access to 'heap' so it cannot decode pointers. */
-+#error debug printing cannot currently be used with heap pointer compression
-+#endif
-+
-+/*
-+ *  Debugger consistency
-+ */
-+
-+#if defined(DUK_USE_DEBUGGER_SUPPORT)
-+#if !defined(DUK_USE_INTERRUPT_COUNTER)
-+#error DUK_USE_INTERRUPT_COUNTER is needed when debugger support is enabled
-+#endif
-+#if !defined(DUK_USE_PC2LINE)
-+#error DUK_USE_PC2LINE is needed when debugger support is enabled
-+#endif
-+#endif
-+
-+/*
-+ *  Garbage collection consistency
-+ */
-+
-+#if defined(DUK_USE_REFERENCE_COUNTING) && !defined(DUK_USE_DOUBLE_LINKED_HEAP)
-+#error DUK_USE_REFERENCE_COUNTING defined without DUK_USE_DOUBLE_LINKED_HEAP
-+#endif
-+
-+#if defined(DUK_USE_GC_TORTURE) && !defined(DUK_USE_MARK_AND_SWEEP)
-+#error DUK_USE_GC_TORTURE defined without DUK_USE_MARK_AND_SWEEP
-+#endif
-+
-+/*
-+ *  Low memory feature consistency
-+ */
-+
-+#if defined(DUK_USE_OBJSIZES16)
-+#if defined(DUK_USE_HOBJECT_HASH_PART)
-+#error DUK_USE_OBJSIZES16 assumes DUK_USE_HOBJECT_HASH_PART is not defined
-+#endif
-+#endif
-+
-+#if defined(DUK_USE_STRTAB_CHAIN) && defined(DUK_USE_STRTAB_PROBE)
-+#error both DUK_USE_STRTAB_CHAIN and DUK_USE_STRTAB_PROBE defined
-+#endif
-+#if !defined(DUK_USE_STRTAB_CHAIN) && !defined(DUK_USE_STRTAB_PROBE)
-+#error neither DUK_USE_STRTAB_CHAIN nor DUK_USE_STRTAB_PROBE is defined
-+#endif
-+
-+#endif  /* DUK_FEATURES_SANITY_H_INCLUDED */
-+
-+/*
-+ *  Union to access IEEE double memory representation, indexes for double
-+ *  memory representation, and some macros for double manipulation.
-+ *
-+ *  Also used by packed duk_tval.  Use a union for bit manipulation to
-+ *  minimize aliasing issues in practice.  The C99 standard does not
-+ *  guarantee that this should work, but it's a very widely supported
-+ *  practice for low level manipulation.
-+ *
-+ *  IEEE double format summary:
-+ *
-+ *    seeeeeee eeeeffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff
-+ *       A        B        C        D        E        F        G        H
-+ *
-+ *    s       sign bit
-+ *    eee...  exponent field
-+ *    fff...  fraction
-+ *
-+ *  See http://en.wikipedia.org/wiki/Double_precision_floating-point_format.
-+ *
-+ *  NaNs are represented as exponent 0x7ff and mantissa != 0.  The NaN is a
-+ *  signaling NaN when the highest bit of the mantissa is zero, and a quiet
-+ *  NaN when the highest bit is set.
-+ *
-+ *  At least three memory layouts are relevant here:
-+ *
-+ *    A B C D E F G H    Big endian (e.g. 68k)           DUK_USE_DOUBLE_BE
-+ *    H G F E D C B A    Little endian (e.g. x86)        DUK_USE_DOUBLE_LE
-+ *    D C B A H G F E    Mixed/cross endian (e.g. ARM)   DUK_USE_DOUBLE_ME
-+ *
-+ *  ARM is a special case: ARM double values are in mixed/cross endian
-+ *  format while ARM duk_uint64_t values are in standard little endian
-+ *  format (H G F E D C B A).  When a double is read as a duk_uint64_t
-+ *  from memory, the register will contain the (logical) value
-+ *  E F G H A B C D.  This requires some special handling below.
-+ *
-+ *  Indexes of various types (8-bit, 16-bit, 32-bit) in memory relative to
-+ *  the logical (big endian) order:
-+ *
-+ *  byte order      duk_uint8_t    duk_uint16_t     duk_uint32_t
-+ *    BE             01234567         0123               01
-+ *    LE             76543210         3210               10
-+ *    ME (ARM)       32107654         1032               01
-+ *
-+ *  Some processors may alter NaN values in a floating point load+store.
-+ *  For instance, on X86 a FLD + FSTP may convert a signaling NaN to a
-+ *  quiet one.  This is catastrophic when NaN space is used in packed
-+ *  duk_tval values.  See: misc/clang_aliasing.c.
-+ */
-+
-+#ifndef DUK_DBLUNION_H_INCLUDED
-+#define DUK_DBLUNION_H_INCLUDED
-+
-+/*
-+ *  Union for accessing double parts, also serves as packed duk_tval
-+ */
-+
-+union duk_double_union {
-+	double d;
-+#ifdef DUK_USE_64BIT_OPS
-+	duk_uint64_t ull[1];
-+#endif
-+	duk_uint32_t ui[2];
-+	duk_uint16_t us[4];
-+	duk_uint8_t uc[8];
-+#ifdef DUK_USE_PACKED_TVAL_POSSIBLE
-+	void *vp[2];  /* used by packed duk_tval, assumes sizeof(void *) == 4 */
-+#endif
-+};
-+
-+typedef union duk_double_union duk_double_union;
-+
-+/*
-+ *  Indexes of various types with respect to big endian (logical) layout
-+ */
-+
-+#if defined(DUK_USE_DOUBLE_LE)
-+#ifdef DUK_USE_64BIT_OPS
-+#define DUK_DBL_IDX_ULL0   0
-+#endif
-+#define DUK_DBL_IDX_UI0    1
-+#define DUK_DBL_IDX_UI1    0
-+#define DUK_DBL_IDX_US0    3
-+#define DUK_DBL_IDX_US1    2
-+#define DUK_DBL_IDX_US2    1
-+#define DUK_DBL_IDX_US3    0
-+#define DUK_DBL_IDX_UC0    7
-+#define DUK_DBL_IDX_UC1    6
-+#define DUK_DBL_IDX_UC2    5
-+#define DUK_DBL_IDX_UC3    4
-+#define DUK_DBL_IDX_UC4    3
-+#define DUK_DBL_IDX_UC5    2
-+#define DUK_DBL_IDX_UC6    1
-+#define DUK_DBL_IDX_UC7    0
-+#define DUK_DBL_IDX_VP0    DUK_DBL_IDX_UI0  /* packed tval */
-+#define DUK_DBL_IDX_VP1    DUK_DBL_IDX_UI1  /* packed tval */
-+#elif defined(DUK_USE_DOUBLE_BE)
-+#ifdef DUK_USE_64BIT_OPS
-+#define DUK_DBL_IDX_ULL0   0
-+#endif
-+#define DUK_DBL_IDX_UI0    0
-+#define DUK_DBL_IDX_UI1    1
-+#define DUK_DBL_IDX_US0    0
-+#define DUK_DBL_IDX_US1    1
-+#define DUK_DBL_IDX_US2    2
-+#define DUK_DBL_IDX_US3    3
-+#define DUK_DBL_IDX_UC0    0
-+#define DUK_DBL_IDX_UC1    1
-+#define DUK_DBL_IDX_UC2    2
-+#define DUK_DBL_IDX_UC3    3
-+#define DUK_DBL_IDX_UC4    4
-+#define DUK_DBL_IDX_UC5    5
-+#define DUK_DBL_IDX_UC6    6
-+#define DUK_DBL_IDX_UC7    7
-+#define DUK_DBL_IDX_VP0    DUK_DBL_IDX_UI0  /* packed tval */
-+#define DUK_DBL_IDX_VP1    DUK_DBL_IDX_UI1  /* packed tval */
-+#elif defined(DUK_USE_DOUBLE_ME)
-+#ifdef DUK_USE_64BIT_OPS
-+#define DUK_DBL_IDX_ULL0   0  /* not directly applicable, byte order differs from a double */
-+#endif
-+#define DUK_DBL_IDX_UI0    0
-+#define DUK_DBL_IDX_UI1    1
-+#define DUK_DBL_IDX_US0    1
-+#define DUK_DBL_IDX_US1    0
-+#define DUK_DBL_IDX_US2    3
-+#define DUK_DBL_IDX_US3    2
-+#define DUK_DBL_IDX_UC0    3
-+#define DUK_DBL_IDX_UC1    2
-+#define DUK_DBL_IDX_UC2    1
-+#define DUK_DBL_IDX_UC3    0
-+#define DUK_DBL_IDX_UC4    7
-+#define DUK_DBL_IDX_UC5    6
-+#define DUK_DBL_IDX_UC6    5
-+#define DUK_DBL_IDX_UC7    4
-+#define DUK_DBL_IDX_VP0    DUK_DBL_IDX_UI0  /* packed tval */
-+#define DUK_DBL_IDX_VP1    DUK_DBL_IDX_UI1  /* packed tval */
-+#else
-+#error internal error
-+#endif
-+
-+/*
-+ *  Helper macros for reading/writing memory representation parts, used
-+ *  by duk_numconv.c and duk_tval.h.
-+ */
-+
-+#define DUK_DBLUNION_SET_DOUBLE(u,v)  do {  \
-+		(u)->d = (v); \
-+	} while (0)
-+
-+#define DUK_DBLUNION_SET_HIGH32(u,v)  do {  \
-+		(u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \
-+	} while (0)
-+
-+#ifdef DUK_USE_64BIT_OPS
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v)  do { \
-+		(u)->ull[DUK_DBL_IDX_ULL0] = (duk_uint64_t) (v); \
-+	} while (0)
-+#else
-+#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v)  do { \
-+		(u)->ull[DUK_DBL_IDX_ULL0] = ((duk_uint64_t) (v)) << 32; \
-+	} while (0)
-+#endif
-+#else  /* DUK_USE_64BIT_OPS */
-+#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v)  do { \
-+		(u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \
-+		(u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) 0; \
-+	} while (0)
-+#endif  /* DUK_USE_64BIT_OPS */
-+
-+#define DUK_DBLUNION_SET_LOW32(u,v)  do {  \
-+		(u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (v); \
-+	} while (0)
-+
-+#define DUK_DBLUNION_GET_DOUBLE(u)  ((u)->d)
-+#define DUK_DBLUNION_GET_HIGH32(u)  ((u)->ui[DUK_DBL_IDX_UI0])
-+#define DUK_DBLUNION_GET_LOW32(u)   ((u)->ui[DUK_DBL_IDX_UI1])
-+
-+#ifdef DUK_USE_64BIT_OPS
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK_DBLUNION_SET_UINT64(u,v)  do { \
-+		(u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) ((v) >> 32); \
-+		(u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (v); \
-+	} while (0)
-+#define DUK_DBLUNION_GET_UINT64(u) \
-+	((((duk_uint64_t) (u)->ui[DUK_DBL_IDX_UI0]) << 32) | \
-+	 ((duk_uint64_t) (u)->ui[DUK_DBL_IDX_UI1]))
-+#else
-+#define DUK_DBLUNION_SET_UINT64(u,v)  do { \
-+		(u)->ull[DUK_DBL_IDX_ULL0] = (duk_uint64_t) (v); \
-+	} while (0)
-+#define DUK_DBLUNION_GET_UINT64(u)  ((u)->ull[DUK_DBL_IDX_ULL0])
-+#endif
-+#define DUK_DBLUNION_SET_INT64(u,v) DUK_DBLUNION_SET_UINT64((u), (duk_uint64_t) (v))
-+#define DUK_DBLUNION_GET_INT64(u)   ((duk_int64_t) DUK_DBLUNION_GET_UINT64((u)))
-+#endif  /* DUK_USE_64BIT_OPS */
-+
-+/*
-+ *  Double NaN manipulation macros related to NaN normalization needed when
-+ *  using the packed duk_tval representation.  NaN normalization is necessary
-+ *  to keep double values compatible with the duk_tval format.
-+ *
-+ *  When packed duk_tval is used, the NaN space is used to store pointers
-+ *  and other tagged values in addition to NaNs.  Actual NaNs are normalized
-+ *  to a specific format.  The macros below are used by the implementation
-+ *  to check and normalize NaN values when they might be created.  The macros
-+ *  are essentially NOPs when the non-packed duk_tval representation is used.
-+ *
-+ *  A FULL check is exact and checks all bits.  A NOTFULL check is used by
-+ *  the packed duk_tval and works correctly for all NaNs except those that
-+ *  begin with 0x7ff0.  Since the 'normalized NaN' values used with packed
-+ *  duk_tval begin with 0x7ff8, the partial check is reliable when packed
-+ *  duk_tval is used.
-+ *
-+ *  The ME variant below is specifically for ARM byte order, which has the
-+ *  feature that while doubles have a mixed byte order (32107654), unsigned
-+ *  long long values has a little endian byte order (76543210).  When writing
-+ *  a logical double value through a ULL pointer, the 32-bit words need to be
-+ *  swapped; hence the #ifdefs below for ULL writes with DUK_USE_DOUBLE_ME.
-+ *  This is not full ARM support but suffices for some environments.
-+ */
-+
-+#ifdef DUK_USE_64BIT_OPS
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK__DBLUNION_SET_NAN_FULL(u)  do { \
-+		(u)->ull[DUK_DBL_IDX_ULL0] = 0x000000007ff80000ULL; \
-+	} while (0)
-+#else
-+#define DUK__DBLUNION_SET_NAN_FULL(u)  do { \
-+		(u)->ull[DUK_DBL_IDX_ULL0] = 0x7ff8000000000000ULL; \
-+	} while (0)
-+#endif
-+#else  /* DUK_USE_64BIT_OPS */
-+#define DUK__DBLUNION_SET_NAN_FULL(u)  do { \
-+		(u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) 0x7ff80000UL; \
-+		(u)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) 0x00000000UL; \
-+	} while (0)
-+#endif  /* DUK_USE_64BIT_OPS */
-+
-+#define DUK__DBLUNION_SET_NAN_NOTFULL(u)  do { \
-+		(u)->us[DUK_DBL_IDX_US0] = 0x7ff8UL; \
-+	} while (0)
-+
-+#ifdef DUK_USE_64BIT_OPS
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK__DBLUNION_IS_NAN_FULL(u) \
-+	/* E == 0x7ff, F != 0 => NaN */ \
-+	((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \
-+	 ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0xffffffff000fffffULL) != 0))
-+#else
-+#define DUK__DBLUNION_IS_NAN_FULL(u) \
-+	/* E == 0x7ff, F != 0 => NaN */ \
-+	((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \
-+	 ((((u)->ull[DUK_DBL_IDX_ULL0]) & 0x000fffffffffffffULL) != 0))
-+#endif
-+#else  /* DUK_USE_64BIT_OPS */
-+#define DUK__DBLUNION_IS_NAN_FULL(u) \
-+	/* E == 0x7ff, F != 0 => NaN */ \
-+	((((u)->ui[DUK_DBL_IDX_UI0] & 0x7ff00000UL) == 0x7ff00000UL) && \
-+	 (((u)->ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) != 0 || \
-+          (u)->ui[DUK_DBL_IDX_UI1] != 0))
-+#endif  /* DUK_USE_64BIT_OPS */
-+
-+#define DUK__DBLUNION_IS_NAN_NOTFULL(u) \
-+	/* E == 0x7ff, topmost four bits of F != 0 => assume NaN */ \
-+	((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && \
-+	 (((u)->us[DUK_DBL_IDX_US0] & 0x000fUL) != 0x0000UL))
-+
-+#ifdef DUK_USE_64BIT_OPS
-+#ifdef DUK_USE_DOUBLE_ME
-+#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
-+	((u)->ull[DUK_DBL_IDX_ULL0] == 0x000000007ff80000ULL)
-+#else
-+#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
-+	((u)->ull[DUK_DBL_IDX_ULL0] == 0x7ff8000000000000ULL)
-+#endif
-+#else  /* DUK_USE_64BIT_OPS */
-+#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
-+	(((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && \
-+	 ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
-+#endif  /* DUK_USE_64BIT_OPS */
-+
-+#define DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL(u) \
-+	/* E == 0x7ff, F == 8 => normalized NaN */ \
-+	((u)->us[DUK_DBL_IDX_US0] == 0x7ff8UL)
-+
-+#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL(u)  do { \
-+		if (DUK__DBLUNION_IS_NAN_FULL((u))) { \
-+			DUK__DBLUNION_SET_NAN_FULL((u)); \
-+		} \
-+	} while (0)
-+
-+#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL(u)  do { \
-+		if (DUK__DBLUNION_IS_NAN_NOTFULL((u))) { \
-+			DUK__DBLUNION_SET_NAN_NOTFULL((u)); \
-+		} \
-+	} while (0)
-+
-+/* Concrete macros for NaN handling used by the implementation internals.
-+ * Chosen so that they match the duk_tval representation: with a packed
-+ * duk_tval, ensure NaNs are properly normalized; with a non-packed duk_tval
-+ * these are essentially NOPs.
-+ */
-+
-+#if defined(DUK_USE_PACKED_TVAL)
-+#if defined(DUK_USE_FULL_TVAL)
-+#define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u)  DUK__DBLUNION_NORMALIZE_NAN_CHECK_FULL((u))
-+#define DUK_DBLUNION_IS_NAN(u)               DUK__DBLUNION_IS_NAN_FULL((u))
-+#define DUK_DBLUNION_IS_NORMALIZED_NAN(u)    DUK__DBLUNION_IS_NORMALIZED_NAN_FULL((u))
-+#define DUK_DBLUNION_SET_NAN(d)              DUK__DBLUNION_SET_NAN_FULL((d))
-+#else
-+#define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u)  DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL((u))
-+#define DUK_DBLUNION_IS_NAN(u)               DUK__DBLUNION_IS_NAN_NOTFULL((u))
-+#define DUK_DBLUNION_IS_NORMALIZED_NAN(u)    DUK__DBLUNION_IS_NORMALIZED_NAN_NOTFULL((u))
-+#define DUK_DBLUNION_SET_NAN(d)              DUK__DBLUNION_SET_NAN_NOTFULL((d))
-+#endif
-+#define DUK_DBLUNION_IS_NORMALIZED(u) \
-+	(!DUK_DBLUNION_IS_NAN((u)) ||  /* either not a NaN */ \
-+	 DUK_DBLUNION_IS_NORMALIZED_NAN((u)))  /* or is a normalized NaN */
-+#else  /* DUK_USE_PACKED_TVAL */
-+#define DUK_DBLUNION_NORMALIZE_NAN_CHECK(u)  /* nop: no need to normalize */
-+#define DUK_DBLUNION_IS_NAN(u)               (DUK_ISNAN((u)->d))
-+#define DUK_DBLUNION_IS_NORMALIZED_NAN(u)    (DUK_ISNAN((u)->d))
-+#define DUK_DBLUNION_IS_NORMALIZED(u)        1  /* all doubles are considered normalized */
-+#define DUK_DBLUNION_SET_NAN(u)  do { \
-+		/* in non-packed representation we don't care about which NaN is used */ \
-+		(u)->d = DUK_DOUBLE_NAN; \
-+	} while (0)
-+#endif  /* DUK_USE_PACKED_TVAL */
-+
-+/* Byteswap an (aligned) duk_double_union. */
-+#if defined(DUK_USE_DOUBLE_LE)
-+#define DUK_DBLUNION_BSWAP(u) do { \
-+		duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \
-+		duk__bswaptmp1 = (u)->ui[0]; \
-+		duk__bswaptmp2 = (u)->ui[1]; \
-+		duk__bswaptmp1 = DUK_BSWAP32(duk__bswaptmp1); \
-+		duk__bswaptmp2 = DUK_BSWAP32(duk__bswaptmp2); \
-+		(u)->ui[0] = duk__bswaptmp2; \
-+		(u)->ui[1] = duk__bswaptmp1; \
-+	} while (0)
-+#elif defined(DUK_USE_DOUBLE_ME)
-+#define DUK_DBLUNION_BSWAP(u) do { \
-+		duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \
-+		duk__bswaptmp1 = (u)->ui[0]; \
-+		duk__bswaptmp2 = (u)->ui[1]; \
-+		duk__bswaptmp1 = DUK_BSWAP32(duk__bswaptmp1); \
-+		duk__bswaptmp2 = DUK_BSWAP32(duk__bswaptmp2); \
-+		(u)->ui[0] = duk__bswaptmp1; \
-+		(u)->ui[1] = duk__bswaptmp2; \
-+	} while (0)
-+#elif defined(DUK_USE_DOUBLE_BE)
-+#define DUK_DBLUNION_BSWAP(u) do { } while (0)
-+#else
-+#error internal error, double endianness insane
-+#endif
-+
-+#endif  /* DUK_DBLUNION_H_INCLUDED */
-+
-+#endif  /* DUKTAPE_H_INCLUDED */
-diff --git a/src/polkitbackend/polkitbackendjsauthority.c b/src/polkitbackend/polkitbackendjsauthority.c
-index 2112868..f6d3694 100644
---- a/src/polkitbackend/polkitbackendjsauthority.c
-+++ b/src/polkitbackend/polkitbackendjsauthority.c
-@@ -43,16 +43,8 @@
- #include <systemd/sd-login.h>
- #endif /* HAVE_LIBSYSTEMD */
- 
--#include <jsapi.h>
--
- #include "initjs.h" /* init.js */
--
--#ifdef JSGC_USE_EXACT_ROOTING
--/* See https://developer.mozilla.org/en-US/docs/SpiderMonkey/Internals/GC/Exact_Stack_Rooting
-- * for more information about exact stack rooting.
-- */
--#error "This code is not safe in SpiderMonkey exact stack rooting configurations"
--#endif
-+#include "duktape.h"
- 
- /**
-  * SECTION:polkitbackendjsauthority
-@@ -72,32 +64,12 @@ struct _PolkitBackendJsAuthorityPrivate
- {
-   gchar **rules_dirs;
-   GFileMonitor **dir_monitors; /* NULL-terminated array of GFileMonitor instances */
-+  duk_context *cx;
- 
--  JSRuntime *rt;
--  JSContext *cx;
--  JSObject *js_global;
--  JSObject *js_polkit;
--
--  GThread *runaway_killer_thread;
--  GMutex rkt_init_mutex;
--  GCond rkt_init_cond;
--  GMainContext *rkt_context;
--  GMainLoop *rkt_loop;
--  GSource *rkt_source;
--  GMutex rkt_timeout_pending_mutex;
--  gboolean rkt_timeout_pending;
--
--  /* A list of JSObject instances */
--  GList *scripts;
-+  gint64 start_time;
- };
- 
--static JSBool execute_script_with_runaway_killer (PolkitBackendJsAuthority *authority,
--#if JS_VERSION == 186
--                                                  JSScript                 *script,
--#else
--                                                  JSObject                 *script,
--#endif
--                                                  jsval                    *rval);
-+#define WATCHDOG_TIMEOUT (15 * G_TIME_SPAN_SECOND)
- 
- static void utils_spawn (const gchar *const  *argv,
-                          guint                timeout_seconds,
-@@ -127,8 +99,6 @@ enum
- 
- /* ---------------------------------------------------------------------------------------------------- */
- 
--static gpointer runaway_killer_thread_func (gpointer user_data);
--
- static GList *polkit_backend_js_authority_get_admin_auth_identities (PolkitBackendInteractiveAuthority *authority,
-                                                                      PolkitSubject                     *caller,
-                                                                      PolkitSubject                     *subject,
-@@ -153,70 +123,8 @@ G_DEFINE_TYPE (PolkitBackendJsAuthority, polkit_backend_js_authority, POLKIT_BAC
- 
- /* ---------------------------------------------------------------------------------------------------- */
- 
--static JSClass js_global_class = {
--  "global",
--  JSCLASS_GLOBAL_FLAGS,
--  JS_PropertyStub,
--  JS_PropertyStub,
--  JS_PropertyStub,
--  JS_StrictPropertyStub,
--  JS_EnumerateStub,
--  JS_ResolveStub,
--  JS_ConvertStub,
--#if JS_VERSION == 186      
--  NULL,
--#else
--  JS_FinalizeStub,
--#endif
--  JSCLASS_NO_OPTIONAL_MEMBERS
--};
--
--/* ---------------------------------------------------------------------------------------------------- */
--
--static JSClass js_polkit_class = {
--  "Polkit",
--  0,
--  JS_PropertyStub,
--  JS_PropertyStub,
--  JS_PropertyStub,
--  JS_StrictPropertyStub,
--  JS_EnumerateStub,
--  JS_ResolveStub,
--  JS_ConvertStub,
--#if JS_VERSION == 186      
--  NULL,
--#else
--  JS_FinalizeStub,
--#endif
--  JSCLASS_NO_OPTIONAL_MEMBERS
--};
--
--static JSBool js_polkit_log (JSContext *cx, unsigned argc, jsval *vp);
--static JSBool js_polkit_spawn (JSContext *cx, unsigned argc, jsval *vp);
--static JSBool js_polkit_user_is_in_netgroup (JSContext *cx, unsigned argc, jsval *vp);
--
--static JSFunctionSpec js_polkit_functions[] =
--{
--  JS_FS("log",            js_polkit_log,            0, 0),
--  JS_FS("spawn",          js_polkit_spawn,          0, 0),
--  JS_FS("_userIsInNetGroup", js_polkit_user_is_in_netgroup,          0, 0),
--  JS_FS_END
--};
--
- /* ---------------------------------------------------------------------------------------------------- */
- 
--static void report_error (JSContext     *cx,
--                          const char    *message,
--                          JSErrorReport *report)
--{
--  PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (JS_GetContextPrivate (cx));
--  polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
--                                "%s:%u: %s",
--                                report->filename ? report->filename : "<no filename>",
--                                (unsigned int) report->lineno,
--                                message);
--}
--
- static void
- polkit_backend_js_authority_init (PolkitBackendJsAuthority *authority)
- {
-@@ -252,10 +160,16 @@ rules_file_name_cmp (const gchar *a,
-   return ret;
- }
- 
--/* authority->priv->cx must be within a request */
-+static void
-+mark_start_time (PolkitBackendJsAuthority *authority)
-+{
-+  authority->priv->start_time = g_get_monotonic_time ();
-+}
-+
- static void
- load_scripts (PolkitBackendJsAuthority  *authority)
- {
-+  duk_context *cx = authority->priv->cx;
-   GList *files = NULL;
-   GList *l;
-   guint num_scripts = 0;
-@@ -300,44 +214,16 @@ load_scripts (PolkitBackendJsAuthority  *authority)
-   for (l = files; l != NULL; l = l->next)
-     {
-       const gchar *filename = l->data;
--#if JS_VERSION == 186
--      JSScript *script;
--#else
--      JSObject *script;
--#endif
- 
--#if JS_VERSION == 186
--      script = JS_CompileUTF8File (authority->priv->cx,
--				   authority->priv->js_global,
--				   filename);
--      
--#else
--      script = JS_CompileFile (authority->priv->cx,
--			       authority->priv->js_global,
--			       filename);
--#endif
--      if (script == NULL)
-+      mark_start_time (authority);
-+      if (duk_peval_file_noresult (cx, filename) != 0)
-         {
-           polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
--                                        "Error compiling script %s",
--                                        filename);
-+                                        "Error compiling script %s: %s",
-+                                        filename, duk_safe_to_string (authority->priv->cx, -1));
-           continue;
-         }
- 
--      /* evaluate the script */
--      jsval rval;
--      if (!execute_script_with_runaway_killer (authority,
--                                               script,
--                                               &rval))
--        {
--          polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
--                                        "Error executing script %s",
--                                        filename);
--          continue;
--        }
--
--      //g_print ("Successfully loaded and evaluated script `%s'\n", filename);
--
-       num_scripts++;
-     }
- 
-@@ -350,37 +236,22 @@ load_scripts (PolkitBackendJsAuthority  *authority)
- static void
- reload_scripts (PolkitBackendJsAuthority *authority)
- {
--  jsval argv[1] = {JSVAL_NULL};
--  jsval rval = JSVAL_NULL;
-+  duk_context *cx = authority->priv->cx;
- 
--  JS_BeginRequest (authority->priv->cx);
-+  duk_set_top (cx, 0);
-+  duk_get_global_string (cx, "polkit");
-+  duk_push_string (cx, "_deleteRules");
- 
--  if (!JS_CallFunctionName(authority->priv->cx,
--                           authority->priv->js_polkit,
--                           "_deleteRules",
--                           0,
--                           argv,
--                           &rval))
--    {
--      polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
--                                    "Error deleting old rules, not loading new ones");
--      goto out;
--    }
-+  mark_start_time (authority);
-+  duk_call_prop (cx, 0, 0);
- 
-   polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
-                                 "Collecting garbage unconditionally...");
--#if JS_VERSION == 186
--  JS_GC (authority->priv->rt);
--#else
--  JS_GC (authority->priv->cx);
--#endif
- 
-   load_scripts (authority);
- 
-   /* Let applications know we have new rules... */
-   g_signal_emit_by_name (authority, "changed");
-- out:
--  JS_EndRequest (authority->priv->cx);
- }
- 
- static void
-@@ -459,71 +330,38 @@ setup_file_monitors (PolkitBackendJsAuthority *authority)
-   authority->priv->dir_monitors = (GFileMonitor**) g_ptr_array_free (p, FALSE);
- }
- 
-+static duk_ret_t js_polkit_log (duk_context *cx);
-+static duk_ret_t js_polkit_spawn (duk_context *cx);
-+static duk_ret_t js_polkit_user_is_in_netgroup (duk_context *cx);
-+
-+static const duk_function_list_entry js_polkit_functions[] =
-+{
-+  { "log", js_polkit_log, 1 },
-+  { "spawn", js_polkit_spawn, 1 },
-+  { "_userIsInNetGroup", js_polkit_user_is_in_netgroup, 2 },
-+  { NULL, NULL, 0 },
-+};
-+
- static void
- polkit_backend_js_authority_constructed (GObject *object)
- {
-   PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (object);
--  gboolean entered_request = FALSE;
--
--  authority->priv->rt = JS_NewRuntime (8L * 1024L * 1024L);
--  if (authority->priv->rt == NULL)
--    goto fail;
-+  duk_context *cx;
- 
--  authority->priv->cx = JS_NewContext (authority->priv->rt, 8192);
--  if (authority->priv->cx == NULL)
--    goto fail;
-+  mark_start_time (authority);
- 
--  /* TODO: JIT'ing doesn't work will with killing runaway scripts... I think
--   *       this is just a SpiderMonkey bug. So disable the JIT for now.
--   */
--  JS_SetOptions (authority->priv->cx,
--                 JSOPTION_VAROBJFIX
--                 /* | JSOPTION_JIT | JSOPTION_METHODJIT*/);
--  JS_SetVersion(authority->priv->cx, JSVERSION_LATEST);
--  JS_SetErrorReporter(authority->priv->cx, report_error);
--  JS_SetContextPrivate (authority->priv->cx, authority);
--
--  JS_BeginRequest(authority->priv->cx);
--  entered_request = TRUE;
--
--  authority->priv->js_global =
--#if JS_VERSION == 186
--    JS_NewGlobalObject (authority->priv->cx, &js_global_class, NULL);
--#else
--    JS_NewCompartmentAndGlobalObject (authority->priv->cx, &js_global_class, NULL);
--#endif
--
--  if (authority->priv->js_global == NULL)
-+  cx = duk_create_heap (NULL, NULL, NULL, authority, NULL);
-+  if (cx == NULL)
-     goto fail;
--  JS_AddObjectRoot (authority->priv->cx, &authority->priv->js_global);
- 
--  if (!JS_InitStandardClasses (authority->priv->cx, authority->priv->js_global))
--    goto fail;
-+  authority->priv->cx = cx;
- 
--  authority->priv->js_polkit = JS_DefineObject (authority->priv->cx,
--                                                authority->priv->js_global,
--                                                "polkit",
--                                                &js_polkit_class,
--                                                NULL,
--                                                JSPROP_ENUMERATE);
--  if (authority->priv->js_polkit == NULL)
--    goto fail;
--  JS_AddObjectRoot (authority->priv->cx, &authority->priv->js_polkit);
--
--  if (!JS_DefineFunctions (authority->priv->cx,
--                           authority->priv->js_polkit,
--                           js_polkit_functions))
--    goto fail;
-+  duk_push_global_object (cx);
-+  duk_push_object (cx);
-+  duk_put_function_list (cx, -1, js_polkit_functions);
-+  duk_put_prop_string (cx, -2, "polkit");
- 
--  if (!JS_EvaluateScript (authority->priv->cx,
--                          authority->priv->js_global,
--                          init_js, strlen (init_js), /* init.js */
--                          "init.js",  /* filename */
--                          0,     /* lineno */
--                          NULL)) /* rval */
--    {
--      goto fail;
--    }
-+  duk_eval_string (cx, init_js);
- 
-   if (authority->priv->rules_dirs == NULL)
-     {
-@@ -532,32 +370,13 @@ polkit_backend_js_authority_constructed (GObject *object)
-       authority->priv->rules_dirs[1] = g_strdup (PACKAGE_DATA_DIR "/polkit-1/rules.d");
-     }
- 
--  g_mutex_init (&authority->priv->rkt_init_mutex);
--  g_cond_init (&authority->priv->rkt_init_cond);
--  g_mutex_init (&authority->priv->rkt_timeout_pending_mutex);
--
--  authority->priv->runaway_killer_thread = g_thread_new ("runaway-killer-thread",
--                                                         runaway_killer_thread_func,
--                                                         authority);
--
--  /* wait for runaway_killer_thread to set up its GMainContext */
--  g_mutex_lock (&authority->priv->rkt_init_mutex);
--  while (authority->priv->rkt_context == NULL)
--    g_cond_wait (&authority->priv->rkt_init_cond, &authority->priv->rkt_init_mutex);
--  g_mutex_unlock (&authority->priv->rkt_init_mutex);
--
-   setup_file_monitors (authority);
-   load_scripts (authority);
- 
--  JS_EndRequest (authority->priv->cx);
--  entered_request = FALSE;
--
-   G_OBJECT_CLASS (polkit_backend_js_authority_parent_class)->constructed (object);
-   return;
- 
-  fail:
--  if (entered_request)
--    JS_EndRequest (authority->priv->cx);
-   g_critical ("Error initializing JavaScript environment");
-   g_assert_not_reached ();
- }
-@@ -568,16 +387,6 @@ polkit_backend_js_authority_finalize (GObject *object)
-   PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (object);
-   guint n;
- 
--  g_mutex_clear (&authority->priv->rkt_init_mutex);
--  g_cond_clear (&authority->priv->rkt_init_cond);
--  g_mutex_clear (&authority->priv->rkt_timeout_pending_mutex);
--
--  /* shut down the killer thread */
--  g_assert (authority->priv->rkt_loop != NULL);
--  g_main_loop_quit (authority->priv->rkt_loop);
--  g_thread_join (authority->priv->runaway_killer_thread);
--  g_assert (authority->priv->rkt_loop == NULL);
--
-   for (n = 0; authority->priv->dir_monitors != NULL && authority->priv->dir_monitors[n] != NULL; n++)
-     {
-       GFileMonitor *monitor = authority->priv->dir_monitors[n];
-@@ -589,14 +398,7 @@ polkit_backend_js_authority_finalize (GObject *object)
-   g_free (authority->priv->dir_monitors);
-   g_strfreev (authority->priv->rules_dirs);
- 
--  JS_BeginRequest (authority->priv->cx);
--  JS_RemoveObjectRoot (authority->priv->cx, &authority->priv->js_polkit);
--  JS_RemoveObjectRoot (authority->priv->cx, &authority->priv->js_global);
--  JS_EndRequest (authority->priv->cx);
--
--  JS_DestroyContext (authority->priv->cx);
--  JS_DestroyRuntime (authority->priv->rt);
--  /* JS_ShutDown (); */
-+  duk_destroy_heap (authority->priv->cx);
- 
-   G_OBJECT_CLASS (polkit_backend_js_authority_parent_class)->finalize (object);
- }
-@@ -676,87 +478,59 @@ polkit_backend_js_authority_class_init (PolkitBackendJsAuthorityClass *klass)
- 
- /* ---------------------------------------------------------------------------------------------------- */
- 
--/* authority->priv->cx must be within a request */
- static void
--set_property_str (PolkitBackendJsAuthority  *authority,
--                  JSObject                  *obj,
--                  const gchar               *name,
--                  const gchar               *value)
-+set_property_str (duk_context *cx,
-+                  const gchar *name,
-+                  const gchar *value)
- {
--  JSString *value_jsstr;
--  jsval value_jsval;
--  value_jsstr = JS_NewStringCopyZ (authority->priv->cx, value);
--  value_jsval = STRING_TO_JSVAL (value_jsstr);
--  JS_SetProperty (authority->priv->cx, obj, name, &value_jsval);
-+  duk_push_string (cx, value);
-+  duk_put_prop_string (cx, -2, name);
- }
- 
--/* authority->priv->cx must be within a request */
- static void
--set_property_strv (PolkitBackendJsAuthority  *authority,
--                   JSObject                  *obj,
--                   const gchar               *name,
--                   GPtrArray                 *value)
-+set_property_strv (duk_context *cx,
-+                   const gchar *name,
-+                   GPtrArray   *value)
- {
--  jsval value_jsval;
--  JSObject *array_object;
-   guint n;
--
--  array_object = JS_NewArrayObject (authority->priv->cx, 0, NULL);
--
-+  duk_push_array (cx);
-   for (n = 0; n < value->len; n++)
-     {
--      JSString *jsstr;
--      jsval val;
--
--      jsstr = JS_NewStringCopyZ (authority->priv->cx, g_ptr_array_index(value, n));
--      val = STRING_TO_JSVAL (jsstr);
--      JS_SetElement (authority->priv->cx, array_object, n, &val);
-+      duk_push_string (cx, g_ptr_array_index (value, n));
-+      duk_put_prop_index (cx, -2, n);
-     }
--
--  value_jsval = OBJECT_TO_JSVAL (array_object);
--  JS_SetProperty (authority->priv->cx, obj, name, &value_jsval);
-+  duk_put_prop_string (cx, -2, name);
- }
- 
--/* authority->priv->cx must be within a request */
- static void
--set_property_int32 (PolkitBackendJsAuthority  *authority,
--                    JSObject                  *obj,
--                    const gchar               *name,
--                    gint32                     value)
-+set_property_int32 (duk_context *cx,
-+                    const gchar *name,
-+                    gint32       value)
- {
--  jsval value_jsval;
--  value_jsval = INT_TO_JSVAL ((gint32) value);
--  JS_SetProperty (authority->priv->cx, obj, name, &value_jsval);
-+  duk_push_int (cx, value);
-+  duk_put_prop_string (cx, -2, name);
- }
- 
--/* authority->priv->cx must be within a request */
- static void
--set_property_bool (PolkitBackendJsAuthority  *authority,
--                   JSObject                  *obj,
--                   const gchar               *name,
--                   gboolean                   value)
-+set_property_bool (duk_context *cx,
-+                   const char  *name,
-+                   gboolean     value)
- {
--  jsval value_jsval;
--  value_jsval = BOOLEAN_TO_JSVAL ((JSBool) value);
--  JS_SetProperty (authority->priv->cx, obj, name, &value_jsval);
-+  duk_push_boolean (cx, value);
-+  duk_put_prop_string (cx, -2, name);
- }
- 
- /* ---------------------------------------------------------------------------------------------------- */
- 
--/* authority->priv->cx must be within a request */
- static gboolean
--subject_to_jsval (PolkitBackendJsAuthority  *authority,
--                  PolkitSubject             *subject,
--                  PolkitIdentity            *user_for_subject,
--                  gboolean                   subject_is_local,
--                  gboolean                   subject_is_active,
--                  jsval                     *out_jsval,
--                  GError                   **error)
-+push_subject (duk_context               *cx,
-+              PolkitSubject             *subject,
-+              PolkitIdentity            *user_for_subject,
-+              gboolean                   subject_is_local,
-+              gboolean                   subject_is_active,
-+              GError                   **error)
- {
-   gboolean ret = FALSE;
--  jsval ret_jsval;
--  const char *src;
--  JSObject *obj;
-   pid_t pid;
-   uid_t uid;
-   gchar *user_name = NULL;
-@@ -765,19 +539,8 @@ subject_to_jsval (PolkitBackendJsAuthority  *authority,
-   char *seat_str = NULL;
-   char *session_str = NULL;
- 
--  src = "new Subject();";
--
--  if (!JS_EvaluateScript (authority->priv->cx,
--                          authority->priv->js_global,
--                          src, strlen (src),
--                          __FILE__, __LINE__,
--                          &ret_jsval))
--    {
--      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Evaluating '%s' failed", src);
--      goto out;
--    }
--
--  obj = JSVAL_TO_OBJECT (ret_jsval);
-+  duk_get_global_string (cx, "Subject");
-+  duk_new (cx, 0);
- 
-   if (POLKIT_IS_UNIX_PROCESS (subject))
-     {
-@@ -851,13 +614,13 @@ subject_to_jsval (PolkitBackendJsAuthority  *authority,
-         }
-     }
- 
--  set_property_int32 (authority, obj, "pid", pid);
--  set_property_str (authority, obj, "user", user_name);
--  set_property_strv (authority, obj, "groups", groups);
--  set_property_str (authority, obj, "seat", seat_str);
--  set_property_str (authority, obj, "session", session_str);
--  set_property_bool (authority, obj, "local", subject_is_local);
--  set_property_bool (authority, obj, "active", subject_is_active);
-+  set_property_int32 (cx, "pid", pid);
-+  set_property_str (cx, "user", user_name);
-+  set_property_strv (cx, "groups", groups);
-+  set_property_str (cx, "seat", seat_str);
-+  set_property_str (cx, "session", session_str);
-+  set_property_bool (cx, "local", subject_is_local);
-+  set_property_bool (cx, "active", subject_is_active);
- 
-   ret = TRUE;
- 
-@@ -868,43 +631,24 @@ subject_to_jsval (PolkitBackendJsAuthority  *authority,
-   if (groups != NULL)
-     g_ptr_array_unref (groups);
- 
--  if (ret && out_jsval != NULL)
--    *out_jsval = ret_jsval;
--
-   return ret;
- }
- 
- /* ---------------------------------------------------------------------------------------------------- */
- 
--/* authority->priv->cx must be within a request */
- static gboolean
--action_and_details_to_jsval (PolkitBackendJsAuthority  *authority,
--                             const gchar               *action_id,
--                             PolkitDetails             *details,
--                             jsval                     *out_jsval,
--                             GError                   **error)
-+push_action_and_details (duk_context               *cx,
-+                         const gchar               *action_id,
-+                         PolkitDetails             *details,
-+                         GError                   **error)
- {
--  gboolean ret = FALSE;
--  jsval ret_jsval;
--  const char *src;
--  JSObject *obj;
-   gchar **keys;
-   guint n;
- 
--  src = "new Action();";
--  if (!JS_EvaluateScript (authority->priv->cx,
--                          authority->priv->js_global,
--                          src, strlen (src),
--                          __FILE__, __LINE__,
--                          &ret_jsval))
--    {
--      g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Evaluating '%s' failed", src);
--      goto out;
--    }
-+  duk_get_global_string (cx, "Action");
-+  duk_new (cx, 0);
- 
--  obj = JSVAL_TO_OBJECT (ret_jsval);
--
--  set_property_str (authority, obj, "id", action_id);
-+  set_property_str (cx, "id", action_id);
- 
-   keys = polkit_details_get_keys (details);
-   for (n = 0; keys != NULL && keys[n] != NULL; n++)
-@@ -913,171 +657,15 @@ action_and_details_to_jsval (PolkitBackendJsAuthority  *authority,
-       const gchar *value;
-       key = g_strdup_printf ("_detail_%s", keys[n]);
-       value = polkit_details_lookup (details, keys[n]);
--      set_property_str (authority, obj, key, value);
-+      set_property_str (cx, key, value);
-       g_free (key);
-     }
-   g_strfreev (keys);
- 
--  ret = TRUE;
--
-- out:
--  if (ret && out_jsval != NULL)
--    *out_jsval = ret_jsval;
--
--  return ret;
--}
--
--/* ---------------------------------------------------------------------------------------------------- */
--
--static gpointer
--runaway_killer_thread_func (gpointer user_data)
--{
--  PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (user_data);
--
--  g_mutex_lock (&authority->priv->rkt_init_mutex);
--
--  authority->priv->rkt_context = g_main_context_new ();
--  authority->priv->rkt_loop = g_main_loop_new (authority->priv->rkt_context, FALSE);
--  g_main_context_push_thread_default (authority->priv->rkt_context);
--
--  /* Signal the main thread that we're done constructing */
--  g_cond_signal (&authority->priv->rkt_init_cond);
--  g_mutex_unlock (&authority->priv->rkt_init_mutex);
--
--  g_main_loop_run (authority->priv->rkt_loop);
--
--  g_main_context_pop_thread_default (authority->priv->rkt_context);
--
--  g_main_loop_unref (authority->priv->rkt_loop);
--  authority->priv->rkt_loop = NULL;
--  g_main_context_unref (authority->priv->rkt_context);
--  authority->priv->rkt_context = NULL;
--
--  return NULL;
--}
--
--/* ---------------------------------------------------------------------------------------------------- */
--
--static JSBool
--js_operation_callback (JSContext *cx)
--{
--  PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (JS_GetContextPrivate (cx));
--  JSString *val_str;
--  jsval val;
--
--  /* This callback can be called by the runtime at any time without us causing
--   * it by JS_TriggerOperationCallback().
--   */
--  g_mutex_lock (&authority->priv->rkt_timeout_pending_mutex);
--  if (!authority->priv->rkt_timeout_pending)
--    {
--      g_mutex_unlock (&authority->priv->rkt_timeout_pending_mutex);
--      return JS_TRUE;
--    }
--  authority->priv->rkt_timeout_pending = FALSE;
--  g_mutex_unlock (&authority->priv->rkt_timeout_pending_mutex);
--
--  /* Log that we are terminating the script */
--  polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority), "Terminating runaway script");
--
--  /* Throw an exception - this way the JS code can ignore the runaway script handling */
--  JS_SetOperationCallback (authority->priv->cx, NULL);
--  val_str = JS_NewStringCopyZ (cx, "Terminating runaway script");
--  val = STRING_TO_JSVAL (val_str);
--  JS_SetPendingException (authority->priv->cx, val);
--  JS_SetOperationCallback (authority->priv->cx, js_operation_callback);
--  return JS_FALSE;
--}
--
--static gboolean
--rkt_on_timeout (gpointer user_data)
--{
--  PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (user_data);
--
--  g_mutex_lock (&authority->priv->rkt_timeout_pending_mutex);
--  authority->priv->rkt_timeout_pending = TRUE;
--  g_mutex_unlock (&authority->priv->rkt_timeout_pending_mutex);
--
--  /* Supposedly this is thread-safe... */
--#if JS_VERSION == 186
--  JS_TriggerOperationCallback (authority->priv->rt);
--#else
--  JS_TriggerOperationCallback (authority->priv->cx);
--#endif
--
--  /* keep source around so we keep trying to kill even if the JS bit catches the exception
--   * thrown in js_operation_callback()
--   */
-   return TRUE;
- }
- 
--static void
--runaway_killer_setup (PolkitBackendJsAuthority *authority)
--{
--  g_assert (authority->priv->rkt_source == NULL);
--
--  /* set-up timer for runaway scripts, will be executed in runaway_killer_thread */
--  g_mutex_lock (&authority->priv->rkt_timeout_pending_mutex);
--  authority->priv->rkt_timeout_pending = FALSE;
--  g_mutex_unlock (&authority->priv->rkt_timeout_pending_mutex);
--  authority->priv->rkt_source = g_timeout_source_new_seconds (15);
--  g_source_set_callback (authority->priv->rkt_source, rkt_on_timeout, authority, NULL);
--  g_source_attach (authority->priv->rkt_source, authority->priv->rkt_context);
--
--  /* ... rkt_on_timeout() will then poke the JSContext so js_operation_callback() is
--   * called... and from there we throw an exception
--   */
--  JS_SetOperationCallback (authority->priv->cx, js_operation_callback);
--}
--
--static void
--runaway_killer_teardown (PolkitBackendJsAuthority *authority)
--{
--  JS_SetOperationCallback (authority->priv->cx, NULL);
--  g_source_destroy (authority->priv->rkt_source);
--  g_source_unref (authority->priv->rkt_source);
--  authority->priv->rkt_source = NULL;
--}
--
--static JSBool
--execute_script_with_runaway_killer (PolkitBackendJsAuthority *authority,
--#if JS_VERSION == 186
--                                    JSScript                 *script,
--#else
--                                    JSObject                 *script,
--#endif
--                                    jsval                    *rval)
--{
--  JSBool ret;
--
--  runaway_killer_setup (authority);
--  ret = JS_ExecuteScript (authority->priv->cx,
--                          authority->priv->js_global,
--                          script,
--                          rval);
--  runaway_killer_teardown (authority);
--
--  return ret;
--}
--
--static JSBool
--call_js_function_with_runaway_killer (PolkitBackendJsAuthority *authority,
--                                      const char               *function_name,
--                                      unsigned                  argc,
--                                      jsval                    *argv,
--                                      jsval                    *rval)
--{
--  JSBool ret;
--  runaway_killer_setup (authority);
--  ret = JS_CallFunctionName(authority->priv->cx,
--                            authority->priv->js_polkit,
--                            function_name,
--                            argc,
--                            argv,
--                            rval);
--  runaway_killer_teardown (authority);
--  return ret;
--}
-+/* ---------------------------------------------------------------------------------------------------- */
- 
- /* ---------------------------------------------------------------------------------------------------- */
- 
-@@ -1093,17 +681,17 @@ polkit_backend_js_authority_get_admin_auth_identities (PolkitBackendInteractiveA
- {
-   PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (_authority);
-   GList *ret = NULL;
--  jsval argv[2] = {JSVAL_NULL, JSVAL_NULL};
--  jsval rval = JSVAL_NULL;
-   guint n;
-   GError *error = NULL;
--  JSString *ret_jsstr;
--  gchar *ret_str = NULL;
-+  const char *ret_str = NULL;
-   gchar **ret_strs = NULL;
-+  duk_context *cx = authority->priv->cx;
- 
--  JS_BeginRequest (authority->priv->cx);
-+  duk_set_top (cx, 0);
-+  duk_get_global_string (cx, "polkit");
-+  duk_push_string (cx, "_runAdminRules");
- 
--  if (!action_and_details_to_jsval (authority, action_id, details, &argv[0], &error))
-+  if (!push_action_and_details (cx, action_id, details, &error))
-     {
-       polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
-                                     "Error converting action and details to JS object: %s",
-@@ -1112,13 +700,7 @@ polkit_backend_js_authority_get_admin_auth_identities (PolkitBackendInteractiveA
-       goto out;
-     }
- 
--  if (!subject_to_jsval (authority,
--                         subject,
--                         user_for_subject,
--                         subject_is_local,
--                         subject_is_active,
--                         &argv[1],
--                         &error))
-+  if (!push_subject (cx, subject, user_for_subject, subject_is_local, subject_is_active, &error))
-     {
-       polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
-                                     "Error converting subject to JS object: %s",
-@@ -1127,30 +709,16 @@ polkit_backend_js_authority_get_admin_auth_identities (PolkitBackendInteractiveA
-       goto out;
-     }
- 
--  if (!call_js_function_with_runaway_killer (authority,
--                                             "_runAdminRules",
--                                             G_N_ELEMENTS (argv),
--                                             argv,
--                                             &rval))
-+  mark_start_time (authority);
-+  if (duk_pcall_prop (cx, 0, 2) != DUK_ERR_NONE)
-     {
-       polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
--                                    "Error evaluating admin rules");
--      goto out;
--    }
--
--  if (!JSVAL_IS_STRING (rval))
--    {
--      g_warning ("Expected a string");
-+                                    "Error evaluating admin rules: ",
-+                                    duk_safe_to_string (cx, -1));
-       goto out;
-     }
- 
--  ret_jsstr = JSVAL_TO_STRING (rval);
--  ret_str = g_utf16_to_utf8 (JS_GetStringCharsZ (authority->priv->cx, ret_jsstr), -1, NULL, NULL, NULL);
--  if (ret_str == NULL)
--    {
--      g_warning ("Error converting resulting string to UTF-8: %s", error->message);
--      goto out;
--    }
-+  ret_str = duk_require_string (cx, -1);
- 
-   ret_strs = g_strsplit (ret_str, ",", -1);
-   for (n = 0; ret_strs != NULL && ret_strs[n] != NULL; n++)
-@@ -1163,8 +731,9 @@ polkit_backend_js_authority_get_admin_auth_identities (PolkitBackendInteractiveA
-       if (identity == NULL)
-         {
-           polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
--                                        "Identity `%s' is not valid, ignoring",
--                                        identity_str);
-+                                        "Identity `%s' is not valid, ignoring: %s",
-+                                        identity_str, error->message);
-+          g_clear_error (&error);
-         }
-       else
-         {
-@@ -1175,15 +744,10 @@ polkit_backend_js_authority_get_admin_auth_identities (PolkitBackendInteractiveA
- 
-  out:
-   g_strfreev (ret_strs);
--  g_free (ret_str);
-   /* fallback to root password auth */
-   if (ret == NULL)
-     ret = g_list_prepend (ret, polkit_unix_user_new (0));
- 
--  JS_MaybeGC (authority->priv->cx);
--
--  JS_EndRequest (authority->priv->cx);
--
-   return ret;
- }
- 
-@@ -1202,17 +766,16 @@ polkit_backend_js_authority_check_authorization_sync (PolkitBackendInteractiveAu
- {
-   PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (_authority);
-   PolkitImplicitAuthorization ret = implicit;
--  jsval argv[2] = {JSVAL_NULL, JSVAL_NULL};
--  jsval rval = JSVAL_NULL; 
-   GError *error = NULL;
--  JSString *ret_jsstr;
--  const jschar *ret_utf16;
-   gchar *ret_str = NULL;
-   gboolean good = FALSE;
-+  duk_context *cx = authority->priv->cx;
- 
--  JS_BeginRequest (authority->priv->cx);
-+  duk_set_top (cx, 0);
-+  duk_get_global_string (cx, "polkit");
-+  duk_push_string (cx, "_runRules");
- 
--  if (!action_and_details_to_jsval (authority, action_id, details, &argv[0], &error))
-+  if (!push_action_and_details (cx, action_id, details, &error))
-     {
-       polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
-                                     "Error converting action and details to JS object: %s",
-@@ -1221,13 +784,7 @@ polkit_backend_js_authority_check_authorization_sync (PolkitBackendInteractiveAu
-       goto out;
-     }
- 
--  if (!subject_to_jsval (authority,
--                         subject,
--                         user_for_subject,
--                         subject_is_local,
--                         subject_is_active,
--                         &argv[1],
--                         &error))
-+  if (!push_subject (cx, subject, user_for_subject, subject_is_local, subject_is_active, &error))
-     {
-       polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
-                                     "Error converting subject to JS object: %s",
-@@ -1236,39 +793,16 @@ polkit_backend_js_authority_check_authorization_sync (PolkitBackendInteractiveAu
-       goto out;
-     }
- 
--  if (!call_js_function_with_runaway_killer (authority,
--                                             "_runRules",
--                                             G_N_ELEMENTS (argv),
--                                             argv,
--                                             &rval))
-+  mark_start_time (authority);
-+  if (duk_pcall_prop (cx, 0, 2) != DUK_ERR_NONE)
-     {
-       polkit_backend_authority_log (POLKIT_BACKEND_AUTHORITY (authority),
--                                    "Error evaluating authorization rules");
--      goto out;
--    }
--
--  if (JSVAL_IS_NULL (rval))
--    {
--      /* this fine, means there was no match, use implicit authorizations */
--      good = TRUE;
-+                                    "Error evaluating authorization rules: ",
-+                                    duk_safe_to_string (cx, -1));
-       goto out;
-     }
- 
--  if (!JSVAL_IS_STRING (rval))
--    {
--      g_warning ("Expected a string");
--      goto out;
--    }
--
--  ret_jsstr = JSVAL_TO_STRING (rval);
--  ret_utf16 = JS_GetStringCharsZ (authority->priv->cx, ret_jsstr);
--  ret_str = g_utf16_to_utf8 (ret_utf16, -1, NULL, NULL, &error);
--  if (ret_str == NULL)
--    {
--      g_warning ("Error converting resulting string to UTF-8: %s", error->message);
--      g_clear_error (&error);
--      goto out;
--    }
-+  ret_str = g_strdup (duk_require_string (cx, -1));
- 
-   g_strstrip (ret_str);
-   if (!polkit_implicit_authorization_from_string (ret_str, &ret))
-@@ -1286,37 +820,17 @@ polkit_backend_js_authority_check_authorization_sync (PolkitBackendInteractiveAu
-     ret = POLKIT_IMPLICIT_AUTHORIZATION_NOT_AUTHORIZED;
-   g_free (ret_str);
- 
--  JS_MaybeGC (authority->priv->cx);
--
--  JS_EndRequest (authority->priv->cx);
--
-   return ret;
- }
- 
- /* ---------------------------------------------------------------------------------------------------- */
- 
--static JSBool
--js_polkit_log (JSContext  *cx,
--               unsigned    argc,
--               jsval      *vp)
-+static duk_ret_t
-+js_polkit_log (duk_context *cx)
- {
--  /* PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (JS_GetContextPrivate (cx)); */
--  JSBool ret = JS_FALSE;
--  JSString *str;
--  char *s;
--
--  if (!JS_ConvertArguments (cx, argc, JS_ARGV (cx, vp), "S", &str))
--    goto out;
--
--  s = JS_EncodeString (cx, str);
--  JS_ReportWarning (cx, s);
--  JS_free (cx, s);
--
--  ret = JS_TRUE;
--
--  JS_SET_RVAL (cx, vp, JSVAL_VOID);  /* return undefined */
-- out:
--  return ret;
-+  const char *str = duk_require_string (cx, 0);
-+  fprintf (stderr, "%s\n", str);
-+  return 0;
- }
- 
- /* ---------------------------------------------------------------------------------------------------- */
-@@ -1380,54 +894,33 @@ spawn_cb (GObject       *source_object,
-   g_main_loop_quit (data->loop);
- }
- 
--static JSBool
--js_polkit_spawn (JSContext  *cx,
--                 unsigned    js_argc,
--                 jsval      *vp)
-+static duk_ret_t
-+js_polkit_spawn (duk_context *cx)
- {
--  /* PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (JS_GetContextPrivate (cx)); */
--  JSBool ret = JS_FALSE;
--  JSObject *array_object;
-+  duk_ret_t ret = DUK_RET_INTERNAL_ERROR;
-   gchar *standard_output = NULL;
-   gchar *standard_error = NULL;
-   gint exit_status;
-   GError *error = NULL;
--  JSString *ret_jsstr;
-   guint32 array_len;
-   gchar **argv = NULL;
-   GMainContext *context = NULL;
-   GMainLoop *loop = NULL;
-   SpawnData data = {0};
-+  char *err_str = NULL;
-   guint n;
- 
--  if (!JS_ConvertArguments (cx, js_argc, JS_ARGV (cx, vp), "o", &array_object))
-+  if (!duk_is_array (cx, 0))
-     goto out;
- 
--  if (!JS_GetArrayLength (cx, array_object, &array_len))
--    {
--      JS_ReportError (cx, "Failed to get array length");
--      goto out;
--    }
-+  array_len = duk_get_length (cx, 0);
- 
-   argv = g_new0 (gchar*, array_len + 1);
-   for (n = 0; n < array_len; n++)
-     {
--      jsval elem_val;
--      char *s;
--
--      if (!JS_GetElement (cx, array_object, n, &elem_val))
--        {
--          JS_ReportError (cx, "Failed to get element %d", n);
--          goto out;
--        }
--      if (!JSVAL_IS_STRING (elem_val))
--	{
--          JS_ReportError (cx, "Element %d is not a string", n);
--          goto out;
--	}
--      s = JS_EncodeString (cx, JSVAL_TO_STRING (elem_val));
--      argv[n] = g_strdup (s);
--      JS_free (cx, s);
-+      duk_get_prop_index (cx, 0, n);
-+      argv[n] = g_strdup (duk_to_string (cx, -1));
-+      duk_pop (cx);
-     }
- 
-   context = g_main_context_new ();
-@@ -1452,9 +945,8 @@ js_polkit_spawn (JSContext  *cx,
-                            &standard_error,
-                            &error))
-     {
--      JS_ReportError (cx,
--                      "Error spawning helper: %s (%s, %d)",
--                      error->message, g_quark_to_string (error->domain), error->code);
-+      err_str = g_strdup_printf ("Error spawning helper: %s (%s, %d)",
-+                                 error->message, g_quark_to_string (error->domain), error->code);
-       g_clear_error (&error);
-       goto out;
-     }
-@@ -1478,15 +970,12 @@ js_polkit_spawn (JSContext  *cx,
-         }
-       g_string_append_printf (gstr, ", stdout=`%s', stderr=`%s'",
-                               standard_output, standard_error);
--      JS_ReportError (cx, gstr->str);
--      g_string_free (gstr, TRUE);
-+      err_str = g_string_free (gstr, FALSE);
-       goto out;
-     }
- 
--  ret = JS_TRUE;
--
--  ret_jsstr = JS_NewStringCopyZ (cx, standard_output);
--  JS_SET_RVAL (cx, vp, STRING_TO_JSVAL (ret_jsstr));
-+  duk_push_string (cx, standard_output);
-+  ret = 1;
- 
-  out:
-   g_strfreev (argv);
-@@ -1497,51 +986,38 @@ js_polkit_spawn (JSContext  *cx,
-     g_main_loop_unref (loop);
-   if (context != NULL)
-     g_main_context_unref (context);
-+
-+  if (err_str)
-+    duk_error (cx, DUK_ERR_ERROR, err_str);
-+
-   return ret;
- }
- 
- /* ---------------------------------------------------------------------------------------------------- */
- 
- 
--static JSBool
--js_polkit_user_is_in_netgroup (JSContext  *cx,
--                               unsigned    argc,
--                               jsval      *vp)
-+static duk_ret_t
-+js_polkit_user_is_in_netgroup (duk_context *cx)
- {
--  /* PolkitBackendJsAuthority *authority = POLKIT_BACKEND_JS_AUTHORITY (JS_GetContextPrivate (cx)); */
--  JSBool ret = JS_FALSE;
--  JSString *user_str;
--  JSString *netgroup_str;
--  char *user;
--  char *netgroup;
--  JSBool is_in_netgroup = JS_FALSE;
--
--  if (!JS_ConvertArguments (cx, argc, JS_ARGV (cx, vp), "SS", &user_str, &netgroup_str))
--    goto out;
-+  const char *user;
-+  const char *netgroup;
-+  gboolean is_in_netgroup = FALSE;
- 
--  user = JS_EncodeString (cx, user_str);
--  netgroup = JS_EncodeString (cx, netgroup_str);
-+  user = duk_require_string (cx, 0);
-+  netgroup = duk_require_string (cx, 1);
- 
-   if (innetgr (netgroup,
-                NULL,  /* host */
-                user,
-                NULL)) /* domain */
-     {
--      is_in_netgroup =  JS_TRUE;
-+      is_in_netgroup = TRUE;
-     }
- 
--  JS_free (cx, netgroup);
--  JS_free (cx, user);
--
--  ret = JS_TRUE;
--
--  JS_SET_RVAL (cx, vp, BOOLEAN_TO_JSVAL (is_in_netgroup));
-- out:
--  return ret;
-+  duk_push_boolean (cx, is_in_netgroup);
-+  return 1;
- }
- 
--
--
- /* ---------------------------------------------------------------------------------------------------- */
- 
- typedef struct
-@@ -1917,3 +1393,27 @@ utils_spawn_finish (GAsyncResult   *res,
-  out:
-   return ret;
- }
-+
-+int
-+polkit_js_exec_timeout_check (const void *udata)
-+{
-+  PolkitBackendJsAuthority *authority = (void *) udata;
-+
-+  gint64 current_time = g_get_monotonic_time ();
-+  gint64 elapsed_time = current_time - authority->priv->start_time;
-+
-+  if (elapsed_time > WATCHDOG_TIMEOUT)
-+    {
-+      /* XXX: The way that the timeout check in Duktape is set up, it
-+       * wants to bubble us all the way out of user code.
-+       *
-+       * The way that our test harness is set up, we need to catch a
-+       * user script gone rogue... from inside... the user script...
-+       * yeah, sure. To do that, "deactivate" the timeout check here
-+       * after we've fired the exception. */
-+      authority->priv->start_time = G_MAXINT64;
-+      return 1;
-+    }
-+
-+  return 0;
-+}
-diff --git a/test/data/etc/polkit-1/rules.d/10-testing.rules b/test/data/etc/polkit-1/rules.d/10-testing.rules
-index 446e622..aa9d9e0 100644
---- a/test/data/etc/polkit-1/rules.d/10-testing.rules
-+++ b/test/data/etc/polkit-1/rules.d/10-testing.rules
-@@ -167,7 +167,7 @@ polkit.addRule(function(action, subject) {
-             while (true)
-                 ;
-         } catch (error) {
--            if (error == "Terminating runaway script")
-+            if (error == "RangeError: execution timeout")
-                 return polkit.Result.YES;
-             return polkit.Result.NO;
-         }
--- 
-1.7.9.2
-