duktape: Import v2.7.0
diff --git a/duktape/duk_config.h b/duktape/duk_config.h
index c7cebde..a4e997e 100644
--- a/duktape/duk_config.h
+++ b/duktape/duk_config.h
@@ -1,9 +1,9 @@
 /*
  *  duk_config.h configuration header generated by genconfig.py.
  *
- *  Git commit: fffa346eff06a8764b02c31d4336f63a773a95c3
- *  Git describe: v2.6.0
- *  Git branch: v2-maintenance
+ *  Git commit: 03d4d728f8365021de6955c649e6dcd05dcca99f
+ *  Git describe: 03d4d72-dirty
+ *  Git branch: HEAD
  *
  *  Supported platforms:
  *      - Mac OSX, iPhone, Darwin
diff --git a/duktape/duktape.c b/duktape/duktape.c
index cd2f791..573e70c 100644
--- a/duktape/duktape.c
+++ b/duktape/duktape.c
@@ -1,8 +1,8 @@
 /*
- *  Single source autogenerated distributable for Duktape 2.6.0.
+ *  Single source autogenerated distributable for Duktape 2.7.0.
  *
- *  Git commit fffa346eff06a8764b02c31d4336f63a773a95c3 (v2.6.0).
- *  Git branch v2-maintenance.
+ *  Git commit 03d4d728f8365021de6955c649e6dcd05dcca99f (03d4d72-dirty).
+ *  Git branch HEAD.
  *
  *  See Duktape AUTHORS.rst and LICENSE.txt for copyright and
  *  licensing information.
@@ -16,7 +16,7 @@
 *
 *  (http://opensource.org/licenses/MIT)
 *
-*  Copyright (c) 2013-2019 by Duktape authors (see AUTHORS.rst)
+*  Copyright (c) 2013-present 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
@@ -105,6 +105,12 @@
 *  * Luis de Bethencourt (https://github.com/luisbg)
 *  * Ian Whyman (https://github.com/v00d00)
 *  * Rick Sayre (https://github.com/whorfin)
+*  * Craig Leres (https://github.com/leres)
+*  * Maurici Abad (https://github.com/mauriciabad)
+*  * Nancy Li (https://github.com/NancyLi1013)
+*  * William Parks (https://github.com/WilliamParks)
+*  * Sam Hellawell (https://github.com/samhellawell)
+*  * Vladislavs Sokurenko (https://github.com/sokurenko)
 *
 *  Other contributions
 *  ===================
@@ -269,7 +275,7 @@
 	duk_uint16_t us[4];
 	duk_uint8_t uc[8];
 #if defined(DUK_USE_PACKED_TVAL)
-	void *vp[2];  /* used by packed duk_tval, assumes sizeof(void *) == 4 */
+	void *vp[2]; /* used by packed duk_tval, assumes sizeof(void *) == 4 */
 #endif
 };
 
@@ -281,64 +287,64 @@
 
 #if defined(DUK_USE_DOUBLE_LE)
 #if defined(DUK_USE_64BIT_OPS)
-#define DUK_DBL_IDX_ULL0   0
+#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 */
+#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)
 #if defined(DUK_USE_64BIT_OPS)
-#define DUK_DBL_IDX_ULL0   0
+#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 */
+#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)
 #if defined(DUK_USE_64BIT_OPS)
-#define DUK_DBL_IDX_ULL0   0  /* not directly applicable, byte order differs from a double */
+#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 */
+#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
@@ -348,57 +354,63 @@
  *  by duk_numconv.c and duk_tval.h.
  */
 
-#define DUK_DBLUNION_SET_DOUBLE(u,v)  do {  \
+#define DUK_DBLUNION_SET_DOUBLE(u, v) \
+	do { \
 		(u)->d = (v); \
 	} while (0)
 
-#define DUK_DBLUNION_SET_HIGH32(u,v)  do {  \
+#define DUK_DBLUNION_SET_HIGH32(u, v) \
+	do { \
 		(u)->ui[DUK_DBL_IDX_UI0] = (duk_uint32_t) (v); \
 	} while (0)
 
 #if defined(DUK_USE_64BIT_OPS)
 #if defined(DUK_USE_DOUBLE_ME)
-#define DUK_DBLUNION_SET_HIGH32_ZERO_LOW32(u,v)  do { \
+#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 { \
+#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 { \
+#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 */
+#endif /* DUK_USE_64BIT_OPS */
 
-#define DUK_DBLUNION_SET_LOW32(u,v)  do {  \
+#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])
+#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])
 
 #if defined(DUK_USE_64BIT_OPS)
 #if defined(DUK_USE_DOUBLE_ME)
-#define DUK_DBLUNION_SET_UINT64(u,v)  do { \
+#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]))
+#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 { \
+#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])
+#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 */
+#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
@@ -429,102 +441,85 @@
 #if defined(DUK_USE_64BIT_OPS)
 #if defined(DUK_USE_DOUBLE_ME)
 /* Macros for 64-bit ops + mixed endian doubles. */
-#define DUK__DBLUNION_SET_NAN_FULL(u)  do { \
+#define DUK__DBLUNION_SET_NAN_FULL(u) \
+	do { \
 		(u)->ull[DUK_DBL_IDX_ULL0] = DUK_U64_CONSTANT(0x000000007ff80000); \
 	} while (0)
 #define DUK__DBLUNION_IS_NAN_FULL(u) \
 	((((u)->ull[DUK_DBL_IDX_ULL0] & DUK_U64_CONSTANT(0x000000007ff00000)) == DUK_U64_CONSTANT(0x000000007ff00000)) && \
 	 ((((u)->ull[DUK_DBL_IDX_ULL0]) & DUK_U64_CONSTANT(0xffffffff000fffff)) != 0))
-#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x000000007ff80000))
+#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x000000007ff80000))
 #define DUK__DBLUNION_IS_ANYINF(u) \
 	(((u)->ull[DUK_DBL_IDX_ULL0] & DUK_U64_CONSTANT(0xffffffff7fffffff)) == DUK_U64_CONSTANT(0x000000007ff00000))
-#define DUK__DBLUNION_IS_POSINF(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x000000007ff00000))
-#define DUK__DBLUNION_IS_NEGINF(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x00000000fff00000))
+#define DUK__DBLUNION_IS_POSINF(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x000000007ff00000))
+#define DUK__DBLUNION_IS_NEGINF(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x00000000fff00000))
 #define DUK__DBLUNION_IS_ANYZERO(u) \
 	(((u)->ull[DUK_DBL_IDX_ULL0] & DUK_U64_CONSTANT(0xffffffff7fffffff)) == DUK_U64_CONSTANT(0x0000000000000000))
-#define DUK__DBLUNION_IS_POSZERO(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x0000000000000000))
-#define DUK__DBLUNION_IS_NEGZERO(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x0000000080000000))
+#define DUK__DBLUNION_IS_POSZERO(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x0000000000000000))
+#define DUK__DBLUNION_IS_NEGZERO(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x0000000080000000))
 #else
 /* Macros for 64-bit ops + big/little endian doubles. */
-#define DUK__DBLUNION_SET_NAN_FULL(u)  do { \
+#define DUK__DBLUNION_SET_NAN_FULL(u) \
+	do { \
 		(u)->ull[DUK_DBL_IDX_ULL0] = DUK_U64_CONSTANT(0x7ff8000000000000); \
 	} while (0)
 #define DUK__DBLUNION_IS_NAN_FULL(u) \
 	((((u)->ull[DUK_DBL_IDX_ULL0] & DUK_U64_CONSTANT(0x7ff0000000000000)) == DUK_U64_CONSTANT(0x7ff0000000000000)) && \
 	 ((((u)->ull[DUK_DBL_IDX_ULL0]) & DUK_U64_CONSTANT(0x000fffffffffffff)) != 0))
-#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x7ff8000000000000))
+#define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x7ff8000000000000))
 #define DUK__DBLUNION_IS_ANYINF(u) \
 	(((u)->ull[DUK_DBL_IDX_ULL0] & DUK_U64_CONSTANT(0x7fffffffffffffff)) == DUK_U64_CONSTANT(0x7ff0000000000000))
-#define DUK__DBLUNION_IS_POSINF(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x7ff0000000000000))
-#define DUK__DBLUNION_IS_NEGINF(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0xfff0000000000000))
+#define DUK__DBLUNION_IS_POSINF(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x7ff0000000000000))
+#define DUK__DBLUNION_IS_NEGINF(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0xfff0000000000000))
 #define DUK__DBLUNION_IS_ANYZERO(u) \
 	(((u)->ull[DUK_DBL_IDX_ULL0] & DUK_U64_CONSTANT(0x7fffffffffffffff)) == DUK_U64_CONSTANT(0x0000000000000000))
-#define DUK__DBLUNION_IS_POSZERO(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x0000000000000000))
-#define DUK__DBLUNION_IS_NEGZERO(u) \
-	((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x8000000000000000))
+#define DUK__DBLUNION_IS_POSZERO(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x0000000000000000))
+#define DUK__DBLUNION_IS_NEGZERO(u) ((u)->ull[DUK_DBL_IDX_ULL0] == DUK_U64_CONSTANT(0x8000000000000000))
 #endif
-#else  /* DUK_USE_64BIT_OPS */
+#else /* DUK_USE_64BIT_OPS */
 /* Macros for no 64-bit ops, any endianness. */
-#define DUK__DBLUNION_SET_NAN_FULL(u)  do { \
+#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)
 #define DUK__DBLUNION_IS_NAN_FULL(u) \
 	((((u)->ui[DUK_DBL_IDX_UI0] & 0x7ff00000UL) == 0x7ff00000UL) && \
-	 (((u)->ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) != 0 || \
-          (u)->ui[DUK_DBL_IDX_UI1] != 0))
+	 (((u)->ui[DUK_DBL_IDX_UI0] & 0x000fffffUL) != 0 || (u)->ui[DUK_DBL_IDX_UI1] != 0))
 #define DUK__DBLUNION_IS_NORMALIZED_NAN_FULL(u) \
-	(((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && \
-	 ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
+	(((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff80000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
 #define DUK__DBLUNION_IS_ANYINF(u) \
-	((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x7ff00000UL) && \
-	 ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
-#define DUK__DBLUNION_IS_POSINF(u) \
-	(((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff00000UL) && \
-	 ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
-#define DUK__DBLUNION_IS_NEGINF(u) \
-	(((u)->ui[DUK_DBL_IDX_UI0] == 0xfff00000UL) && \
-	 ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
+	((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x7ff00000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
+#define DUK__DBLUNION_IS_POSINF(u) (((u)->ui[DUK_DBL_IDX_UI0] == 0x7ff00000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
+#define DUK__DBLUNION_IS_NEGINF(u) (((u)->ui[DUK_DBL_IDX_UI0] == 0xfff00000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
 #define DUK__DBLUNION_IS_ANYZERO(u) \
-	((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x00000000UL) && \
-	 ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
-#define DUK__DBLUNION_IS_POSZERO(u) \
-	(((u)->ui[DUK_DBL_IDX_UI0] == 0x00000000UL) && \
-	 ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
-#define DUK__DBLUNION_IS_NEGZERO(u) \
-	(((u)->ui[DUK_DBL_IDX_UI0] == 0x80000000UL) && \
-	 ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
-#endif  /* DUK_USE_64BIT_OPS */
+	((((u)->ui[DUK_DBL_IDX_UI0] & 0x7fffffffUL) == 0x00000000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
+#define DUK__DBLUNION_IS_POSZERO(u) (((u)->ui[DUK_DBL_IDX_UI0] == 0x00000000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
+#define DUK__DBLUNION_IS_NEGZERO(u) (((u)->ui[DUK_DBL_IDX_UI0] == 0x80000000UL) && ((u)->ui[DUK_DBL_IDX_UI1] == 0x00000000UL))
+#endif /* DUK_USE_64BIT_OPS */
 
-#define DUK__DBLUNION_SET_NAN_NOTFULL(u)  do { \
+#define DUK__DBLUNION_SET_NAN_NOTFULL(u) \
+	do { \
 		(u)->us[DUK_DBL_IDX_US0] = 0x7ff8UL; \
 	} while (0)
 
 #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))
+	((((u)->us[DUK_DBL_IDX_US0] & 0x7ff0UL) == 0x7ff0UL) && (((u)->us[DUK_DBL_IDX_US0] & 0x000fUL) != 0x0000UL))
 
 #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 { \
+#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 { \
+#define DUK__DBLUNION_NORMALIZE_NAN_CHECK_NOTFULL(u) \
+	do { \
 		/* Check must be full. */ \
 		if (DUK__DBLUNION_IS_NAN_FULL((u))) { \
 			DUK__DBLUNION_SET_NAN_NOTFULL((u)); \
@@ -538,29 +533,30 @@
  */
 
 #if defined(DUK_USE_PACKED_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))
+#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))
 #if 0
-#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))
+#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__DBLUNION_IS_NAN_FULL((u))  /* (DUK_ISNAN((u)->d)) */
-#define DUK_DBLUNION_IS_NORMALIZED_NAN(u)    DUK__DBLUNION_IS_NAN_FULL((u))  /* (DUK_ISNAN((u)->d)) */
-#define DUK_DBLUNION_IS_NORMALIZED(u)        1  /* all doubles are considered normalized */
-#define DUK_DBLUNION_SET_NAN(u)  do { \
+	(!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__DBLUNION_IS_NAN_FULL((u)) /* (DUK_ISNAN((u)->d)) */
+#define DUK_DBLUNION_IS_NORMALIZED_NAN(u)   DUK__DBLUNION_IS_NAN_FULL((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 */
+#endif /* DUK_USE_PACKED_TVAL */
 
 #define DUK_DBLUNION_IS_ANYINF(u) DUK__DBLUNION_IS_ANYINF((u))
 #define DUK_DBLUNION_IS_POSINF(u) DUK__DBLUNION_IS_POSINF((u))
@@ -573,7 +569,8 @@
 /* XXX: native 64-bit byteswaps when available */
 
 /* 64-bit byteswap, same operation independent of target endianness. */
-#define DUK_DBLUNION_BSWAP64(u) do { \
+#define DUK_DBLUNION_BSWAP64(u) \
+	do { \
 		duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \
 		duk__bswaptmp1 = (u)->ui[0]; \
 		duk__bswaptmp2 = (u)->ui[1]; \
@@ -587,7 +584,8 @@
  * order.  For a big endian target this is a no-op.
  */
 #if defined(DUK_USE_DOUBLE_LE)
-#define DUK_DBLUNION_DOUBLE_HTON(u) do { \
+#define DUK_DBLUNION_DOUBLE_HTON(u) \
+	do { \
 		duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \
 		duk__bswaptmp1 = (u)->ui[0]; \
 		duk__bswaptmp2 = (u)->ui[1]; \
@@ -597,7 +595,8 @@
 		(u)->ui[1] = duk__bswaptmp1; \
 	} while (0)
 #elif defined(DUK_USE_DOUBLE_ME)
-#define DUK_DBLUNION_DOUBLE_HTON(u) do { \
+#define DUK_DBLUNION_DOUBLE_HTON(u) \
+	do { \
 		duk_uint32_t duk__bswaptmp1, duk__bswaptmp2; \
 		duk__bswaptmp1 = (u)->ui[0]; \
 		duk__bswaptmp2 = (u)->ui[1]; \
@@ -607,7 +606,9 @@
 		(u)->ui[1] = duk__bswaptmp2; \
 	} while (0)
 #elif defined(DUK_USE_DOUBLE_BE)
-#define DUK_DBLUNION_DOUBLE_HTON(u) do { } while (0)
+#define DUK_DBLUNION_DOUBLE_HTON(u) \
+	do { \
+	} while (0)
 #else
 #error internal error, double endianness insane
 #endif
@@ -624,7 +625,7 @@
 #define DUK_DBLUNION_GET_SIGNBIT(u) (((u)->ui[DUK_DBL_IDX_UI0] >> 31U))
 #endif
 
-#endif  /* DUK_DBLUNION_H_INCLUDED */
+#endif /* DUK_DBLUNION_H_INCLUDED */
 /* #include duk_fltunion.h */
 #line 1 "duk_fltunion.h"
 /*
@@ -646,26 +647,26 @@
 typedef union duk_float_union duk_float_union;
 
 #if defined(DUK_USE_DOUBLE_LE) || defined(DUK_USE_DOUBLE_ME)
-#define DUK_FLT_IDX_UI0    0
-#define DUK_FLT_IDX_US0    1
-#define DUK_FLT_IDX_US1    0
-#define DUK_FLT_IDX_UC0    3
-#define DUK_FLT_IDX_UC1    2
-#define DUK_FLT_IDX_UC2    1
-#define DUK_FLT_IDX_UC3    0
+#define DUK_FLT_IDX_UI0 0
+#define DUK_FLT_IDX_US0 1
+#define DUK_FLT_IDX_US1 0
+#define DUK_FLT_IDX_UC0 3
+#define DUK_FLT_IDX_UC1 2
+#define DUK_FLT_IDX_UC2 1
+#define DUK_FLT_IDX_UC3 0
 #elif defined(DUK_USE_DOUBLE_BE)
-#define DUK_FLT_IDX_UI0    0
-#define DUK_FLT_IDX_US0    0
-#define DUK_FLT_IDX_US1    1
-#define DUK_FLT_IDX_UC0    0
-#define DUK_FLT_IDX_UC1    1
-#define DUK_FLT_IDX_UC2    2
-#define DUK_FLT_IDX_UC3    3
+#define DUK_FLT_IDX_UI0 0
+#define DUK_FLT_IDX_US0 0
+#define DUK_FLT_IDX_US1 1
+#define DUK_FLT_IDX_UC0 0
+#define DUK_FLT_IDX_UC1 1
+#define DUK_FLT_IDX_UC2 2
+#define DUK_FLT_IDX_UC3 3
 #else
 #error internal error
 #endif
 
-#endif  /* DUK_FLTUNION_H_INCLUDED */
+#endif /* DUK_FLTUNION_H_INCLUDED */
 /* #include duk_replacements.h */
 #line 1 "duk_replacements.h"
 #if !defined(DUK_REPLACEMENTS_H_INCLUDED)
@@ -678,7 +679,7 @@
 #if defined(DUK_USE_COMPUTED_NAN)
 DUK_INTERNAL_DECL double duk_computed_nan;
 #endif
-#endif  /* !DUK_SINGLE_FILE */
+#endif /* !DUK_SINGLE_FILE */
 
 #if defined(DUK_USE_REPL_FPCLASSIFY)
 DUK_INTERNAL_DECL int duk_repl_fpclassify(double x);
@@ -696,7 +697,7 @@
 DUK_INTERNAL_DECL int duk_repl_isinf(double x);
 #endif
 
-#endif  /* DUK_REPLACEMENTS_H_INCLUDED */
+#endif /* DUK_REPLACEMENTS_H_INCLUDED */
 /* #include duk_jmpbuf.h */
 #line 1 "duk_jmpbuf.h"
 /*
@@ -714,7 +715,7 @@
 
 #if defined(DUK_USE_CPP_EXCEPTIONS)
 struct duk_jmpbuf {
-	duk_small_int_t dummy;  /* unused */
+	duk_small_int_t dummy; /* unused */
 };
 #else
 struct duk_jmpbuf {
@@ -722,7 +723,7 @@
 };
 #endif
 
-#endif  /* DUK_JMPBUF_H_INCLUDED */
+#endif /* DUK_JMPBUF_H_INCLUDED */
 /* #include duk_exception.h */
 #line 1 "duk_exception.h"
 /*
@@ -749,12 +750,13 @@
  * aware of the "unsafe to continue" semantics.
  */
 class duk_fatal_exception : public virtual std::runtime_error {
- public:
-	duk_fatal_exception(const char *message) : std::runtime_error(message) {}
+      public:
+	duk_fatal_exception(const char *message) : std::runtime_error(message) {
+	}
 };
 #endif
 
-#endif  /* DUK_EXCEPTION_H_INCLUDED */
+#endif /* DUK_EXCEPTION_H_INCLUDED */
 /* #include duk_forwdecl.h */
 #line 1 "duk_forwdecl.h"
 /*
@@ -890,7 +892,7 @@
 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 */
+#endif /* DUK_FORWDECL_H_INCLUDED */
 /* #include duk_tval.h */
 #line 1 "duk_tval.h"
 /*
@@ -936,30 +938,29 @@
 } duk_tval_unused;
 
 /* tags */
-#define DUK_TAG_NORMALIZED_NAN    0x7ff8UL   /* the NaN variant we use */
+#define DUK_TAG_NORMALIZED_NAN 0x7ff8UL /* the NaN variant we use */
 /* avoid tag 0xfff0, no risk of confusion with negative infinity */
-#define DUK_TAG_MIN               0xfff1UL
+#define DUK_TAG_MIN            0xfff1UL
 #if defined(DUK_USE_FASTINT)
-#define DUK_TAG_FASTINT           0xfff1UL   /* embed: integer value */
+#define DUK_TAG_FASTINT 0xfff1UL /* embed: integer value */
 #endif
-#define DUK_TAG_UNUSED            0xfff2UL   /* marker; not actual tagged value */
-#define DUK_TAG_UNDEFINED         0xfff3UL   /* embed: nothing */
-#define DUK_TAG_NULL              0xfff4UL   /* embed: nothing */
-#define DUK_TAG_BOOLEAN           0xfff5UL   /* embed: 0 or 1 (false or true) */
+#define DUK_TAG_UNUSED    0xfff2UL /* marker; not actual tagged value */
+#define DUK_TAG_UNDEFINED 0xfff3UL /* embed: nothing */
+#define DUK_TAG_NULL      0xfff4UL /* embed: nothing */
+#define DUK_TAG_BOOLEAN   0xfff5UL /* embed: 0 or 1 (false or true) */
 /* DUK_TAG_NUMBER would logically go here, but it has multiple 'tags' */
-#define DUK_TAG_POINTER           0xfff6UL   /* embed: void ptr */
-#define DUK_TAG_LIGHTFUNC         0xfff7UL   /* embed: func ptr */
-#define DUK_TAG_STRING            0xfff8UL   /* embed: duk_hstring ptr */
-#define DUK_TAG_OBJECT            0xfff9UL   /* embed: duk_hobject ptr */
-#define DUK_TAG_BUFFER            0xfffaUL   /* embed: duk_hbuffer ptr */
-#define DUK_TAG_MAX               0xfffaUL
+#define DUK_TAG_POINTER   0xfff6UL /* embed: void ptr */
+#define DUK_TAG_LIGHTFUNC 0xfff7UL /* embed: func ptr */
+#define DUK_TAG_STRING    0xfff8UL /* embed: duk_hstring ptr */
+#define DUK_TAG_OBJECT    0xfff9UL /* embed: duk_hobject ptr */
+#define DUK_TAG_BUFFER    0xfffaUL /* embed: duk_hbuffer ptr */
+#define DUK_TAG_MAX       0xfffaUL
 
 /* for convenience */
-#define DUK_XTAG_BOOLEAN_FALSE    0xfff50000UL
-#define DUK_XTAG_BOOLEAN_TRUE     0xfff50001UL
+#define DUK_XTAG_BOOLEAN_FALSE 0xfff50000UL
+#define DUK_XTAG_BOOLEAN_TRUE  0xfff50001UL
 
-#define DUK_TVAL_IS_VALID_TAG(tv) \
-	(DUK_TVAL_GET_TAG((tv)) - DUK_TAG_MIN <= DUK_TAG_MAX - DUK_TAG_MIN)
+#define DUK_TVAL_IS_VALID_TAG(tv) (DUK_TVAL_GET_TAG((tv)) - DUK_TAG_MIN <= DUK_TAG_MAX - DUK_TAG_MIN)
 
 /* DUK_TVAL_UNUSED initializer for duk_tval_unused, works for any endianness. */
 #define DUK_TVAL_UNUSED_INITIALIZER() \
@@ -968,116 +969,136 @@
 /* two casts to avoid gcc warning: "warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]" */
 #if defined(DUK_USE_64BIT_OPS)
 #if defined(DUK_USE_DOUBLE_ME)
-#define DUK__TVAL_SET_TAGGEDPOINTER(tv,h,tag)  do { \
+#define DUK__TVAL_SET_TAGGEDPOINTER(tv, h, tag) \
+	do { \
 		(tv)->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(tv,h,tag)  do { \
+#define DUK__TVAL_SET_TAGGEDPOINTER(tv, h, tag) \
+	do { \
 		(tv)->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(tv,h,tag)  do { \
+#else /* DUK_USE_64BIT_OPS */
+#define DUK__TVAL_SET_TAGGEDPOINTER(tv, h, tag) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) (tag)) << 16; \
 		duk__tv->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (h); \
 	} while (0)
-#endif  /* DUK_USE_64BIT_OPS */
+#endif /* DUK_USE_64BIT_OPS */
 
 #if defined(DUK_USE_64BIT_OPS)
 /* Double casting for pointer to avoid gcc warning (cast from pointer to integer of different size) */
 #if defined(DUK_USE_DOUBLE_ME)
-#define DUK__TVAL_SET_LIGHTFUNC(tv,fp,flags)  do { \
-		(tv)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_LIGHTFUNC) << 16) | \
-		                              ((duk_uint64_t) (flags)) | \
+#define DUK__TVAL_SET_LIGHTFUNC(tv, fp, flags) \
+	do { \
+		(tv)->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(tv,fp,flags)  do { \
-		(tv)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_LIGHTFUNC) << 48) | \
-		                              (((duk_uint64_t) (flags)) << 32) | \
+#define DUK__TVAL_SET_LIGHTFUNC(tv, fp, flags) \
+	do { \
+		(tv)->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(tv,fp,flags)  do { \
+#else /* DUK_USE_64BIT_OPS */
+#define DUK__TVAL_SET_LIGHTFUNC(tv, fp, flags) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->ui[DUK_DBL_IDX_UI0] = (((duk_uint32_t) DUK_TAG_LIGHTFUNC) << 16) | ((duk_uint32_t) (flags)); \
 		duk__tv->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (fp); \
 	} while (0)
-#endif  /* DUK_USE_64BIT_OPS */
+#endif /* DUK_USE_64BIT_OPS */
 
 #if defined(DUK_USE_FASTINT)
 /* Note: masking is done for 'i' to deal with negative numbers correctly */
 #if defined(DUK_USE_DOUBLE_ME)
-#define DUK__TVAL_SET_I48(tv,i)  do { \
+#define DUK__TVAL_SET_I48(tv, i) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
-		duk__tv->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) DUK_TAG_FASTINT) << 16 | (((duk_uint32_t) ((i) >> 32)) & 0x0000ffffUL); \
+		duk__tv->ui[DUK_DBL_IDX_UI0] = \
+		    ((duk_uint32_t) DUK_TAG_FASTINT) << 16 | (((duk_uint32_t) ((i) >> 32)) & 0x0000ffffUL); \
 		duk__tv->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (i); \
 	} while (0)
-#define DUK__TVAL_SET_U32(tv,i)  do { \
+#define DUK__TVAL_SET_U32(tv, i) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) DUK_TAG_FASTINT) << 16; \
 		duk__tv->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (i); \
 	} while (0)
 #else
-#define DUK__TVAL_SET_I48(tv,i)  do { \
-		(tv)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (((duk_uint64_t) (i)) & DUK_U64_CONSTANT(0x0000ffffffffffff)); \
+#define DUK__TVAL_SET_I48(tv, i) \
+	do { \
+		(tv)->ull[DUK_DBL_IDX_ULL0] = \
+		    (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (((duk_uint64_t) (i)) & DUK_U64_CONSTANT(0x0000ffffffffffff)); \
 	} while (0)
-#define DUK__TVAL_SET_U32(tv,i)  do { \
+#define DUK__TVAL_SET_U32(tv, i) \
+	do { \
 		(tv)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (duk_uint64_t) (i); \
 	} while (0)
 #endif
 
 /* This needs to go through a cast because sign extension is needed. */
-#define DUK__TVAL_SET_I32(tv,i)  do { \
+#define DUK__TVAL_SET_I32(tv, i) \
+	do { \
 		duk_int64_t duk__tmp = (duk_int64_t) (i); \
 		DUK_TVAL_SET_I48((tv), duk__tmp); \
 	} while (0)
 
 /* XXX: Clumsy sign extend and masking of 16 topmost bits. */
 #if defined(DUK_USE_DOUBLE_ME)
-#define DUK__TVAL_GET_FASTINT(tv)      (((duk_int64_t) ((((duk_uint64_t) (tv)->ui[DUK_DBL_IDX_UI0]) << 32) | ((duk_uint64_t) (tv)->ui[DUK_DBL_IDX_UI1]))) << 16 >> 16)
+#define DUK__TVAL_GET_FASTINT(tv) \
+	(((duk_int64_t) ((((duk_uint64_t) (tv)->ui[DUK_DBL_IDX_UI0]) << 32) | ((duk_uint64_t) (tv)->ui[DUK_DBL_IDX_UI1]))) \
+	     << 16 >> \
+	 16)
 #else
-#define DUK__TVAL_GET_FASTINT(tv)      ((((duk_int64_t) (tv)->ull[DUK_DBL_IDX_ULL0]) << 16) >> 16)
+#define DUK__TVAL_GET_FASTINT(tv) ((((duk_int64_t) (tv)->ull[DUK_DBL_IDX_ULL0]) << 16) >> 16)
 #endif
-#define DUK__TVAL_GET_FASTINT_U32(tv)  ((tv)->ui[DUK_DBL_IDX_UI1])
-#define DUK__TVAL_GET_FASTINT_I32(tv)  ((duk_int32_t) (tv)->ui[DUK_DBL_IDX_UI1])
-#endif  /* DUK_USE_FASTINT */
+#define DUK__TVAL_GET_FASTINT_U32(tv) ((tv)->ui[DUK_DBL_IDX_UI1])
+#define DUK__TVAL_GET_FASTINT_I32(tv) ((duk_int32_t) (tv)->ui[DUK_DBL_IDX_UI1])
+#endif /* DUK_USE_FASTINT */
 
-#define DUK_TVAL_SET_UNDEFINED(tv)  do { \
+#define DUK_TVAL_SET_UNDEFINED(tv) \
+	do { \
 		(tv)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_UNDEFINED; \
 	} while (0)
-#define DUK_TVAL_SET_UNUSED(tv)  do { \
+#define DUK_TVAL_SET_UNUSED(tv) \
+	do { \
 		(tv)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_UNUSED; \
 	} while (0)
-#define DUK_TVAL_SET_NULL(tv)  do { \
+#define DUK_TVAL_SET_NULL(tv) \
+	do { \
 		(tv)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_NULL; \
 	} while (0)
 
-#define DUK_TVAL_SET_BOOLEAN(tv,val)         DUK_DBLUNION_SET_HIGH32((tv), (((duk_uint32_t) DUK_TAG_BOOLEAN) << 16) | ((duk_uint32_t) (val)))
+#define DUK_TVAL_SET_BOOLEAN(tv, val) \
+	DUK_DBLUNION_SET_HIGH32((tv), (((duk_uint32_t) DUK_TAG_BOOLEAN) << 16) | ((duk_uint32_t) (val)))
 
-#define DUK_TVAL_SET_NAN(tv)                 DUK_DBLUNION_SET_NAN_FULL((tv))
+#define DUK_TVAL_SET_NAN(tv) DUK_DBLUNION_SET_NAN_FULL((tv))
 
 /* Assumes that caller has normalized NaNs, otherwise trouble ahead. */
 #if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_DOUBLE(tv,d)  do { \
+#define DUK_TVAL_SET_DOUBLE(tv, d) \
+	do { \
 		duk_double_t duk__dblval; \
 		duk__dblval = (d); \
 		DUK_ASSERT_DOUBLE_IS_NORMALIZED(duk__dblval); \
 		DUK_DBLUNION_SET_DOUBLE((tv), duk__dblval); \
 	} while (0)
-#define DUK_TVAL_SET_I48(tv,i)               DUK__TVAL_SET_I48((tv), (i))
-#define DUK_TVAL_SET_I32(tv,i)               DUK__TVAL_SET_I32((tv), (i))
-#define DUK_TVAL_SET_U32(tv,i)               DUK__TVAL_SET_U32((tv), (i))
-#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv,d)  duk_tval_set_number_chkfast_fast((tv), (d))
-#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv,d)  duk_tval_set_number_chkfast_slow((tv), (d))
-#define DUK_TVAL_SET_NUMBER(tv,d)            DUK_TVAL_SET_DOUBLE((tv), (d))
-#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv)  do { \
+#define DUK_TVAL_SET_I48(tv, i)                 DUK__TVAL_SET_I48((tv), (i))
+#define DUK_TVAL_SET_I32(tv, i)                 DUK__TVAL_SET_I32((tv), (i))
+#define DUK_TVAL_SET_U32(tv, i)                 DUK__TVAL_SET_U32((tv), (i))
+#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv, d) duk_tval_set_number_chkfast_fast((tv), (d))
+#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv, d) duk_tval_set_number_chkfast_slow((tv), (d))
+#define DUK_TVAL_SET_NUMBER(tv, d)              DUK_TVAL_SET_DOUBLE((tv), (d))
+#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv) \
+	do { \
 		duk_tval *duk__tv; \
 		duk_double_t duk__d; \
 		duk__tv = (tv); \
@@ -1086,7 +1107,8 @@
 			DUK_TVAL_SET_NUMBER_CHKFAST_FAST(duk__tv, duk__d); \
 		} \
 	} while (0)
-#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv)  do { \
+#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv) \
+	do { \
 		duk_tval *duk__tv; \
 		duk_double_t duk__d; \
 		duk__tv = (tv); \
@@ -1095,89 +1117,98 @@
 			DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(duk__tv, duk__d); \
 		} \
 	} while (0)
-#else  /* DUK_USE_FASTINT */
-#define DUK_TVAL_SET_DOUBLE(tv,d)  do { \
+#else /* DUK_USE_FASTINT */
+#define DUK_TVAL_SET_DOUBLE(tv, d) \
+	do { \
 		duk_double_t duk__dblval; \
 		duk__dblval = (d); \
 		DUK_ASSERT_DOUBLE_IS_NORMALIZED(duk__dblval); \
 		DUK_DBLUNION_SET_DOUBLE((tv), duk__dblval); \
 	} while (0)
-#define DUK_TVAL_SET_I48(tv,i)               DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i))  /* XXX: fast int-to-double */
-#define DUK_TVAL_SET_I32(tv,i)               DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i))
-#define DUK_TVAL_SET_U32(tv,i)               DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i))
-#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv,d)    DUK_TVAL_SET_DOUBLE((tv), (d))
-#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv,d)    DUK_TVAL_SET_DOUBLE((tv), (d))
-#define DUK_TVAL_SET_NUMBER(tv,d)            DUK_TVAL_SET_DOUBLE((tv), (d))
-#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv)  do { } while (0)
-#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv)  do { } while (0)
-#endif  /* DUK_USE_FASTINT */
+#define DUK_TVAL_SET_I48(tv, i)                 DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i)) /* XXX: fast int-to-double */
+#define DUK_TVAL_SET_I32(tv, i)                 DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i))
+#define DUK_TVAL_SET_U32(tv, i)                 DUK_TVAL_SET_DOUBLE((tv), (duk_double_t) (i))
+#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv, d) DUK_TVAL_SET_DOUBLE((tv), (d))
+#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv, d) DUK_TVAL_SET_DOUBLE((tv), (d))
+#define DUK_TVAL_SET_NUMBER(tv, d)              DUK_TVAL_SET_DOUBLE((tv), (d))
+#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv) \
+	do { \
+	} while (0)
+#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv) \
+	do { \
+	} while (0)
+#endif /* DUK_USE_FASTINT */
 
-#define DUK_TVAL_SET_FASTINT(tv,i)           DUK_TVAL_SET_I48((tv), (i))  /* alias */
+#define DUK_TVAL_SET_FASTINT(tv, i) DUK_TVAL_SET_I48((tv), (i)) /* alias */
 
-#define DUK_TVAL_SET_LIGHTFUNC(tv,fp,flags)  DUK__TVAL_SET_LIGHTFUNC((tv), (fp), (flags))
-#define DUK_TVAL_SET_STRING(tv,h)            DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_STRING)
-#define DUK_TVAL_SET_OBJECT(tv,h)            DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_OBJECT)
-#define DUK_TVAL_SET_BUFFER(tv,h)            DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_BUFFER)
-#define DUK_TVAL_SET_POINTER(tv,p)           DUK__TVAL_SET_TAGGEDPOINTER((tv), (p), DUK_TAG_POINTER)
+#define DUK_TVAL_SET_LIGHTFUNC(tv, fp, flags) DUK__TVAL_SET_LIGHTFUNC((tv), (fp), (flags))
+#define DUK_TVAL_SET_STRING(tv, h)            DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_STRING)
+#define DUK_TVAL_SET_OBJECT(tv, h)            DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_OBJECT)
+#define DUK_TVAL_SET_BUFFER(tv, h)            DUK__TVAL_SET_TAGGEDPOINTER((tv), (h), DUK_TAG_BUFFER)
+#define DUK_TVAL_SET_POINTER(tv, p)           DUK__TVAL_SET_TAGGEDPOINTER((tv), (p), DUK_TAG_POINTER)
 
-#define DUK_TVAL_SET_TVAL(tv,x)              do { *(tv) = *(x); } while (0)
+#define DUK_TVAL_SET_TVAL(tv, x) \
+	do { \
+		*(tv) = *(x); \
+	} while (0)
 
 /* getters */
-#define DUK_TVAL_GET_BOOLEAN(tv)             ((duk_small_uint_t) (tv)->us[DUK_DBL_IDX_US1])
+#define DUK_TVAL_GET_BOOLEAN(tv) ((duk_small_uint_t) (tv)->us[DUK_DBL_IDX_US1])
 #if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_GET_DOUBLE(tv)              ((tv)->d)
-#define DUK_TVAL_GET_FASTINT(tv)             DUK__TVAL_GET_FASTINT((tv))
-#define DUK_TVAL_GET_FASTINT_U32(tv)         DUK__TVAL_GET_FASTINT_U32((tv))
-#define DUK_TVAL_GET_FASTINT_I32(tv)         DUK__TVAL_GET_FASTINT_I32((tv))
-#define DUK_TVAL_GET_NUMBER(tv)              duk_tval_get_number_packed((tv))
+#define DUK_TVAL_GET_DOUBLE(tv)      ((tv)->d)
+#define DUK_TVAL_GET_FASTINT(tv)     DUK__TVAL_GET_FASTINT((tv))
+#define DUK_TVAL_GET_FASTINT_U32(tv) DUK__TVAL_GET_FASTINT_U32((tv))
+#define DUK_TVAL_GET_FASTINT_I32(tv) DUK__TVAL_GET_FASTINT_I32((tv))
+#define DUK_TVAL_GET_NUMBER(tv)      duk_tval_get_number_packed((tv))
 #else
-#define DUK_TVAL_GET_NUMBER(tv)              ((tv)->d)
-#define DUK_TVAL_GET_DOUBLE(tv)              ((tv)->d)
+#define DUK_TVAL_GET_NUMBER(tv) ((tv)->d)
+#define DUK_TVAL_GET_DOUBLE(tv) ((tv)->d)
 #endif
-#define DUK_TVAL_GET_LIGHTFUNC(tv,out_fp,out_flags)  do { \
+#define DUK_TVAL_GET_LIGHTFUNC(tv, out_fp, out_flags) \
+	do { \
 		(out_flags) = (tv)->ui[DUK_DBL_IDX_UI0] & 0xffffUL; \
 		(out_fp) = (duk_c_function) (tv)->ui[DUK_DBL_IDX_UI1]; \
 	} while (0)
-#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv)   ((duk_c_function) ((tv)->ui[DUK_DBL_IDX_UI1]))
-#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv)     (((duk_small_uint_t) (tv)->ui[DUK_DBL_IDX_UI0]) & 0xffffUL)
-#define DUK_TVAL_GET_STRING(tv)              ((duk_hstring *) (tv)->vp[DUK_DBL_IDX_VP1])
-#define DUK_TVAL_GET_OBJECT(tv)              ((duk_hobject *) (tv)->vp[DUK_DBL_IDX_VP1])
-#define DUK_TVAL_GET_BUFFER(tv)              ((duk_hbuffer *) (tv)->vp[DUK_DBL_IDX_VP1])
-#define DUK_TVAL_GET_POINTER(tv)             ((void *) (tv)->vp[DUK_DBL_IDX_VP1])
-#define DUK_TVAL_GET_HEAPHDR(tv)             ((duk_heaphdr *) (tv)->vp[DUK_DBL_IDX_VP1])
+#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv) ((duk_c_function) ((tv)->ui[DUK_DBL_IDX_UI1]))
+#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv)   (((duk_small_uint_t) (tv)->ui[DUK_DBL_IDX_UI0]) & 0xffffUL)
+#define DUK_TVAL_GET_STRING(tv)            ((duk_hstring *) (tv)->vp[DUK_DBL_IDX_VP1])
+#define DUK_TVAL_GET_OBJECT(tv)            ((duk_hobject *) (tv)->vp[DUK_DBL_IDX_VP1])
+#define DUK_TVAL_GET_BUFFER(tv)            ((duk_hbuffer *) (tv)->vp[DUK_DBL_IDX_VP1])
+#define DUK_TVAL_GET_POINTER(tv)           ((void *) (tv)->vp[DUK_DBL_IDX_VP1])
+#define DUK_TVAL_GET_HEAPHDR(tv)           ((duk_heaphdr *) (tv)->vp[DUK_DBL_IDX_VP1])
 
 /* decoding */
-#define DUK_TVAL_GET_TAG(tv)                 ((duk_small_uint_t) (tv)->us[DUK_DBL_IDX_US0])
+#define DUK_TVAL_GET_TAG(tv) ((duk_small_uint_t) (tv)->us[DUK_DBL_IDX_US0])
 
-#define DUK_TVAL_IS_UNDEFINED(tv)            (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_UNDEFINED)
-#define DUK_TVAL_IS_UNUSED(tv)               (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_UNUSED)
-#define DUK_TVAL_IS_NULL(tv)                 (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_NULL)
-#define DUK_TVAL_IS_BOOLEAN(tv)              (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_BOOLEAN)
-#define DUK_TVAL_IS_BOOLEAN_TRUE(tv)         ((tv)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_TRUE)
-#define DUK_TVAL_IS_BOOLEAN_FALSE(tv)        ((tv)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_FALSE)
-#define DUK_TVAL_IS_LIGHTFUNC(tv)            (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_LIGHTFUNC)
-#define DUK_TVAL_IS_STRING(tv)               (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_STRING)
-#define DUK_TVAL_IS_OBJECT(tv)               (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_OBJECT)
-#define DUK_TVAL_IS_BUFFER(tv)               (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_BUFFER)
-#define DUK_TVAL_IS_POINTER(tv)              (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_POINTER)
+#define DUK_TVAL_IS_UNDEFINED(tv)     (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_UNDEFINED)
+#define DUK_TVAL_IS_UNUSED(tv)        (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_UNUSED)
+#define DUK_TVAL_IS_NULL(tv)          (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_NULL)
+#define DUK_TVAL_IS_BOOLEAN(tv)       (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_BOOLEAN)
+#define DUK_TVAL_IS_BOOLEAN_TRUE(tv)  ((tv)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_TRUE)
+#define DUK_TVAL_IS_BOOLEAN_FALSE(tv) ((tv)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_FALSE)
+#define DUK_TVAL_IS_LIGHTFUNC(tv)     (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_LIGHTFUNC)
+#define DUK_TVAL_IS_STRING(tv)        (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_STRING)
+#define DUK_TVAL_IS_OBJECT(tv)        (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_OBJECT)
+#define DUK_TVAL_IS_BUFFER(tv)        (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_BUFFER)
+#define DUK_TVAL_IS_POINTER(tv)       (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_POINTER)
 #if defined(DUK_USE_FASTINT)
 /* 0xfff0 is -Infinity */
-#define DUK_TVAL_IS_DOUBLE(tv)               (DUK_TVAL_GET_TAG((tv)) <= 0xfff0UL)
-#define DUK_TVAL_IS_FASTINT(tv)              (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_FASTINT)
-#define DUK_TVAL_IS_NUMBER(tv)               (DUK_TVAL_GET_TAG((tv)) <= 0xfff1UL)
+#define DUK_TVAL_IS_DOUBLE(tv)  (DUK_TVAL_GET_TAG((tv)) <= 0xfff0UL)
+#define DUK_TVAL_IS_FASTINT(tv) (DUK_TVAL_GET_TAG((tv)) == DUK_TAG_FASTINT)
+#define DUK_TVAL_IS_NUMBER(tv)  (DUK_TVAL_GET_TAG((tv)) <= 0xfff1UL)
 #else
-#define DUK_TVAL_IS_NUMBER(tv)               (DUK_TVAL_GET_TAG((tv)) <= 0xfff0UL)
-#define DUK_TVAL_IS_DOUBLE(tv)               DUK_TVAL_IS_NUMBER((tv))
+#define DUK_TVAL_IS_NUMBER(tv) (DUK_TVAL_GET_TAG((tv)) <= 0xfff0UL)
+#define DUK_TVAL_IS_DOUBLE(tv) DUK_TVAL_IS_NUMBER((tv))
 #endif
 
 /* This is performance critical because it appears in every DECREF. */
-#define DUK_TVAL_IS_HEAP_ALLOCATED(tv)       (DUK_TVAL_GET_TAG((tv)) >= DUK_TAG_STRING)
+#define DUK_TVAL_IS_HEAP_ALLOCATED(tv) (DUK_TVAL_GET_TAG((tv)) >= DUK_TAG_STRING)
 
 #if defined(DUK_USE_FASTINT)
 DUK_INTERNAL_DECL duk_double_t duk_tval_get_number_packed(duk_tval *tv);
 #endif
 
-#else  /* DUK_USE_PACKED_TVAL */
+#else /* DUK_USE_PACKED_TVAL */
 /* ======================================================================== */
 
 /*
@@ -1201,7 +1232,7 @@
 		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 */
+		duk_int64_t fi; /* if present, forces 16-byte duk_tval */
 #endif
 		void *voidptr;
 		duk_hstring *hstring;
@@ -1229,24 +1260,23 @@
 #define DUK_TVAL_UNUSED_INITIALIZER() \
 	{ DUK_TAG_UNUSED, 0, 0.0 }
 
-#define DUK_TAG_MIN                   0
-#define DUK_TAG_NUMBER                0  /* DUK_TAG_NUMBER only defined for non-packed duk_tval */
+#define DUK_TAG_MIN    0
+#define DUK_TAG_NUMBER 0 /* DUK_TAG_NUMBER only defined for non-packed duk_tval */
 #if defined(DUK_USE_FASTINT)
-#define DUK_TAG_FASTINT               1
+#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_UNUSED                7  /* marker; not actual tagged type */
-#define DUK_TAG_STRING                8  /* first heap allocated, match bit boundary */
-#define DUK_TAG_OBJECT                9
-#define DUK_TAG_BUFFER                10
-#define DUK_TAG_MAX                   10
+#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_UNUSED    7 /* marker; not actual tagged type */
+#define DUK_TAG_STRING    8 /* first heap allocated, match bit boundary */
+#define DUK_TAG_OBJECT    9
+#define DUK_TAG_BUFFER    10
+#define DUK_TAG_MAX       10
 
-#define DUK_TVAL_IS_VALID_TAG(tv) \
-	(DUK_TVAL_GET_TAG((tv)) - DUK_TAG_MIN <= DUK_TAG_MAX - DUK_TAG_MIN)
+#define DUK_TVAL_IS_VALID_TAG(tv) (DUK_TVAL_GET_TAG((tv)) - DUK_TAG_MIN <= DUK_TAG_MAX - DUK_TAG_MIN)
 
 /* 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
@@ -1255,25 +1285,29 @@
  */
 
 /* setters */
-#define DUK_TVAL_SET_UNDEFINED(tv)  do { \
+#define DUK_TVAL_SET_UNDEFINED(tv) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_UNDEFINED; \
 	} while (0)
 
-#define DUK_TVAL_SET_UNUSED(tv)  do { \
+#define DUK_TVAL_SET_UNUSED(tv) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_UNUSED; \
 	} while (0)
 
-#define DUK_TVAL_SET_NULL(tv)  do { \
+#define DUK_TVAL_SET_NULL(tv) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_NULL; \
 	} while (0)
 
-#define DUK_TVAL_SET_BOOLEAN(tv,val)  do { \
+#define DUK_TVAL_SET_BOOLEAN(tv, val) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_BOOLEAN; \
@@ -1281,7 +1315,8 @@
 	} while (0)
 
 #if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_DOUBLE(tv,val)  do { \
+#define DUK_TVAL_SET_DOUBLE(tv, val) \
+	do { \
 		duk_tval *duk__tv; \
 		duk_double_t duk__dblval; \
 		duk__dblval = (val); \
@@ -1290,31 +1325,32 @@
 		duk__tv->t = DUK_TAG_NUMBER; \
 		duk__tv->v.d = duk__dblval; \
 	} while (0)
-#define DUK_TVAL_SET_I48(tv,val)  do { \
+#define DUK_TVAL_SET_I48(tv, val) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_FASTINT; \
 		duk__tv->v.fi = (val); \
 	} while (0)
-#define DUK_TVAL_SET_U32(tv,val)  do { \
+#define DUK_TVAL_SET_U32(tv, val) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_FASTINT; \
 		duk__tv->v.fi = (duk_int64_t) (val); \
 	} while (0)
-#define DUK_TVAL_SET_I32(tv,val)  do { \
+#define DUK_TVAL_SET_I32(tv, val) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_FASTINT; \
 		duk__tv->v.fi = (duk_int64_t) (val); \
 	} while (0)
-#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv,d) \
-	duk_tval_set_number_chkfast_fast((tv), (d))
-#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv,d) \
-	duk_tval_set_number_chkfast_slow((tv), (d))
-#define DUK_TVAL_SET_NUMBER(tv,val) \
-	DUK_TVAL_SET_DOUBLE((tv), (val))
-#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv)  do { \
+#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv, d) duk_tval_set_number_chkfast_fast((tv), (d))
+#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv, d) duk_tval_set_number_chkfast_slow((tv), (d))
+#define DUK_TVAL_SET_NUMBER(tv, val)            DUK_TVAL_SET_DOUBLE((tv), (val))
+#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv) \
+	do { \
 		duk_tval *duk__tv; \
 		duk_double_t duk__d; \
 		duk__tv = (tv); \
@@ -1323,7 +1359,8 @@
 			DUK_TVAL_SET_NUMBER_CHKFAST_FAST(duk__tv, duk__d); \
 		} \
 	} while (0)
-#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv)  do { \
+#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv) \
+	do { \
 		duk_tval *duk__tv; \
 		duk_double_t duk__d; \
 		duk__tv = (tv); \
@@ -1332,16 +1369,13 @@
 			DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(duk__tv, duk__d); \
 		} \
 	} while (0)
-#else  /* DUK_USE_FASTINT */
-#define DUK_TVAL_SET_DOUBLE(tv,d) \
-	DUK_TVAL_SET_NUMBER((tv), (d))
-#define DUK_TVAL_SET_I48(tv,val) \
-	DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))  /* XXX: fast int-to-double */
-#define DUK_TVAL_SET_U32(tv,val) \
-	DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))
-#define DUK_TVAL_SET_I32(tv,val) \
-	DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))
-#define DUK_TVAL_SET_NUMBER(tv,val)  do { \
+#else /* DUK_USE_FASTINT */
+#define DUK_TVAL_SET_DOUBLE(tv, d) DUK_TVAL_SET_NUMBER((tv), (d))
+#define DUK_TVAL_SET_I48(tv, val)  DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val)) /* XXX: fast int-to-double */
+#define DUK_TVAL_SET_U32(tv, val)  DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))
+#define DUK_TVAL_SET_I32(tv, val)  DUK_TVAL_SET_NUMBER((tv), (duk_double_t) (val))
+#define DUK_TVAL_SET_NUMBER(tv, val) \
+	do { \
 		duk_tval *duk__tv; \
 		duk_double_t duk__dblval; \
 		duk__dblval = (val); \
@@ -1350,25 +1384,28 @@
 		duk__tv->t = DUK_TAG_NUMBER; \
 		duk__tv->v.d = duk__dblval; \
 	} while (0)
-#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv,d) \
-	DUK_TVAL_SET_NUMBER((tv), (d))
-#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv,d) \
-	DUK_TVAL_SET_NUMBER((tv), (d))
-#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv)  do { } while (0)
-#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv)  do { } while (0)
-#endif  /* DUK_USE_FASTINT */
+#define DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv, d) DUK_TVAL_SET_NUMBER((tv), (d))
+#define DUK_TVAL_SET_NUMBER_CHKFAST_SLOW(tv, d) DUK_TVAL_SET_NUMBER((tv), (d))
+#define DUK_TVAL_CHKFAST_INPLACE_FAST(tv) \
+	do { \
+	} while (0)
+#define DUK_TVAL_CHKFAST_INPLACE_SLOW(tv) \
+	do { \
+	} while (0)
+#endif /* DUK_USE_FASTINT */
 
-#define DUK_TVAL_SET_FASTINT(tv,i) \
-	DUK_TVAL_SET_I48((tv), (i))  /* alias */
+#define DUK_TVAL_SET_FASTINT(tv, i) DUK_TVAL_SET_I48((tv), (i)) /* alias */
 
-#define DUK_TVAL_SET_POINTER(tv,hptr)  do { \
+#define DUK_TVAL_SET_POINTER(tv, hptr) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_POINTER; \
 		duk__tv->v.voidptr = (hptr); \
 	} while (0)
 
-#define DUK_TVAL_SET_LIGHTFUNC(tv,fp,flags)  do { \
+#define DUK_TVAL_SET_LIGHTFUNC(tv, fp, flags) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_LIGHTFUNC; \
@@ -1376,28 +1413,32 @@
 		duk__tv->v.lightfunc = (duk_c_function) (fp); \
 	} while (0)
 
-#define DUK_TVAL_SET_STRING(tv,hptr)  do { \
+#define DUK_TVAL_SET_STRING(tv, hptr) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_STRING; \
 		duk__tv->v.hstring = (hptr); \
 	} while (0)
 
-#define DUK_TVAL_SET_OBJECT(tv,hptr)  do { \
+#define DUK_TVAL_SET_OBJECT(tv, hptr) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_OBJECT; \
 		duk__tv->v.hobject = (hptr); \
 	} while (0)
 
-#define DUK_TVAL_SET_BUFFER(tv,hptr)  do { \
+#define DUK_TVAL_SET_BUFFER(tv, hptr) \
+	do { \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
 		duk__tv->t = DUK_TAG_BUFFER; \
 		duk__tv->v.hbuffer = (hptr); \
 	} while (0)
 
-#define DUK_TVAL_SET_NAN(tv)  do { \
+#define DUK_TVAL_SET_NAN(tv) \
+	do { \
 		/* in non-packed representation we don't care about which NaN is used */ \
 		duk_tval *duk__tv; \
 		duk__tv = (tv); \
@@ -1405,32 +1446,32 @@
 		duk__tv->v.d = DUK_DOUBLE_NAN; \
 	} while (0)
 
-#define DUK_TVAL_SET_TVAL(tv,x)            do { *(tv) = *(x); } while (0)
+#define DUK_TVAL_SET_TVAL(tv, x) \
+	do { \
+		*(tv) = *(x); \
+	} while (0)
 
 /* getters */
-#define DUK_TVAL_GET_BOOLEAN(tv)           ((duk_small_uint_t) (tv)->v.i)
+#define DUK_TVAL_GET_BOOLEAN(tv) ((duk_small_uint_t) (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))
+#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))
+#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)))
+#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 { \
+#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)
@@ -1450,19 +1491,18 @@
 #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)
+#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(tv)             DUK_TVAL_IS_NUMBER((tv))
-#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_NUMBER(tv) ((tv)->t == DUK_TAG_NUMBER)
+#define DUK_TVAL_IS_DOUBLE(tv) DUK_TVAL_IS_NUMBER((tv))
+#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)
 
 /* This is performance critical because it's needed for every DECREF.
  * Take advantage of the fact that the first heap allocated tag is 8,
@@ -1470,9 +1510,9 @@
  * non-heap-allocated tags).
  */
 #if 0
-#define DUK_TVAL_IS_HEAP_ALLOCATED(tv)     ((tv)->t >= DUK_TAG_STRING)
+#define DUK_TVAL_IS_HEAP_ALLOCATED(tv) ((tv)->t >= DUK_TAG_STRING)
 #endif
-#define DUK_TVAL_IS_HEAP_ALLOCATED(tv)     ((tv)->t & 0x08)
+#define DUK_TVAL_IS_HEAP_ALLOCATED(tv) ((tv)->t & 0x08)
 
 #if defined(DUK_USE_FASTINT)
 #if 0
@@ -1481,44 +1521,39 @@
 DUK_INTERNAL_DECL duk_double_t duk_tval_get_number_unpacked_fastint(duk_tval *tv);
 #endif
 
-#endif  /* DUK_USE_PACKED_TVAL */
+#endif /* DUK_USE_PACKED_TVAL */
 
 /*
  *  Convenience (independent of representation)
  */
 
-#define DUK_TVAL_SET_BOOLEAN_TRUE(tv)        DUK_TVAL_SET_BOOLEAN((tv), 1)
-#define DUK_TVAL_SET_BOOLEAN_FALSE(tv)       DUK_TVAL_SET_BOOLEAN((tv), 0)
+#define DUK_TVAL_SET_BOOLEAN_TRUE(tv)  DUK_TVAL_SET_BOOLEAN((tv), 1)
+#define DUK_TVAL_SET_BOOLEAN_FALSE(tv) DUK_TVAL_SET_BOOLEAN((tv), 0)
 
-#define DUK_TVAL_STRING_IS_SYMBOL(tv) \
-	DUK_HSTRING_HAS_SYMBOL(DUK_TVAL_GET_STRING((tv)))
+#define DUK_TVAL_STRING_IS_SYMBOL(tv) DUK_HSTRING_HAS_SYMBOL(DUK_TVAL_GET_STRING((tv)))
 
 /* Lightfunc flags packing and unpacking. */
 /* Sign extend: 0x0000##00 -> 0x##000000 -> sign extend to 0xssssss##.
  * Avoid signed shifts due to portability limitations.
  */
-#define DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags) \
-	((duk_int32_t) (duk_int8_t) (((duk_uint16_t) (lf_flags)) >> 8))
-#define DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags) \
-	(((lf_flags) >> 4) & 0x0fU)
-#define DUK_LFUNC_FLAGS_GET_NARGS(lf_flags) \
-	((lf_flags) & 0x0fU)
-#define DUK_LFUNC_FLAGS_PACK(magic,length,nargs) \
-	((((duk_small_uint_t) (magic)) & 0xffU) << 8) | ((length) << 4) | (nargs)
+#define DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags)        ((duk_int32_t) (duk_int8_t) (((duk_uint16_t) (lf_flags)) >> 8))
+#define DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags)       (((lf_flags) >> 4) & 0x0fU)
+#define DUK_LFUNC_FLAGS_GET_NARGS(lf_flags)        ((lf_flags) &0x0fU)
+#define DUK_LFUNC_FLAGS_PACK(magic, length, nargs) ((((duk_small_uint_t) (magic)) & 0xffU) << 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
+#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           (DUK_I64_CONSTANT(-0x800000000000))
-#define DUK_FASTINT_MAX           (DUK_I64_CONSTANT(0x7fffffffffff))
-#define DUK_FASTINT_BITS          48
+#define DUK_FASTINT_MIN  (DUK_I64_CONSTANT(-0x800000000000))
+#define DUK_FASTINT_MAX  (DUK_I64_CONSTANT(0x7fffffffffff))
+#define DUK_FASTINT_BITS 48
 
 DUK_INTERNAL_DECL void duk_tval_set_number_chkfast_fast(duk_tval *tv, duk_double_t x);
 DUK_INTERNAL_DECL void duk_tval_set_number_chkfast_slow(duk_tval *tv, duk_double_t x);
@@ -1526,12 +1561,17 @@
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_tval_assert_valid(duk_tval *tv);
-#define DUK_TVAL_ASSERT_VALID(tv)  do { duk_tval_assert_valid((tv)); } while (0)
+#define DUK_TVAL_ASSERT_VALID(tv) \
+	do { \
+		duk_tval_assert_valid((tv)); \
+	} while (0)
 #else
-#define DUK_TVAL_ASSERT_VALID(tv)  do {} while (0)
+#define DUK_TVAL_ASSERT_VALID(tv) \
+	do { \
+	} while (0)
 #endif
 
-#endif  /* DUK_TVAL_H_INCLUDED */
+#endif /* DUK_TVAL_H_INCLUDED */
 /* #include duk_builtins.h */
 #line 1 "duk_builtins.h"
 /*
@@ -2336,20 +2376,14 @@
 #if !defined(DUK_UTIL_H_INCLUDED)
 #define DUK_UTIL_H_INCLUDED
 
-#if defined(DUK_USE_GET_RANDOM_DOUBLE)
-#define DUK_UTIL_GET_RANDOM_DOUBLE(thr) DUK_USE_GET_RANDOM_DOUBLE((thr)->heap_udata)
-#else
-#define DUK_UTIL_GET_RANDOM_DOUBLE(thr) duk_util_tinyrandom_get_double(thr)
-#endif
-
 /*
  *  Some useful constants
  */
 
-#define DUK_DOUBLE_2TO32     4294967296.0
-#define DUK_DOUBLE_2TO31     2147483648.0
-#define DUK_DOUBLE_LOG2E     1.4426950408889634
-#define DUK_DOUBLE_LOG10E    0.4342944819032518
+#define DUK_DOUBLE_2TO32  4294967296.0
+#define DUK_DOUBLE_2TO31  2147483648.0
+#define DUK_DOUBLE_LOG2E  1.4426950408889634
+#define DUK_DOUBLE_LOG10E 0.4342944819032518
 
 /*
  *  Endian conversion
@@ -2402,33 +2436,35 @@
  *  update the pointer argument automatically.
  */
 
-#define DUK_RAW_WRITE_U8(ptr,val)  do { \
+#define DUK_RAW_WRITE_U8(ptr, val) \
+	do { \
 		*(ptr) = (duk_uint8_t) (val); \
 	} while (0)
-#define DUK_RAW_WRITE_U16_BE(ptr,val) duk_raw_write_u16_be((ptr), (duk_uint16_t) (val))
-#define DUK_RAW_WRITE_U32_BE(ptr,val) duk_raw_write_u32_be((ptr), (duk_uint32_t) (val))
-#define DUK_RAW_WRITE_FLOAT_BE(ptr,val) duk_raw_write_float_be((ptr), (duk_float_t) (val))
-#define DUK_RAW_WRITE_DOUBLE_BE(ptr,val) duk_raw_write_double_be((ptr), (duk_double_t) (val))
-#define DUK_RAW_WRITE_XUTF8(ptr,val) duk_raw_write_xutf8((ptr), (duk_ucodepoint_t) (val))
+#define DUK_RAW_WRITE_U16_BE(ptr, val)    duk_raw_write_u16_be((ptr), (duk_uint16_t) (val))
+#define DUK_RAW_WRITE_U32_BE(ptr, val)    duk_raw_write_u32_be((ptr), (duk_uint32_t) (val))
+#define DUK_RAW_WRITE_FLOAT_BE(ptr, val)  duk_raw_write_float_be((ptr), (duk_float_t) (val))
+#define DUK_RAW_WRITE_DOUBLE_BE(ptr, val) duk_raw_write_double_be((ptr), (duk_double_t) (val))
+#define DUK_RAW_WRITE_XUTF8(ptr, val)     duk_raw_write_xutf8((ptr), (duk_ucodepoint_t) (val))
 
-#define DUK_RAW_WRITEINC_U8(ptr,val)  do { \
+#define DUK_RAW_WRITEINC_U8(ptr, val) \
+	do { \
 		*(ptr)++ = (duk_uint8_t) (val); \
 	} while (0)
-#define DUK_RAW_WRITEINC_U16_BE(ptr,val) duk_raw_writeinc_u16_be(&(ptr), (duk_uint16_t) (val))
-#define DUK_RAW_WRITEINC_U32_BE(ptr,val) duk_raw_writeinc_u32_be(&(ptr), (duk_uint32_t) (val))
-#define DUK_RAW_WRITEINC_FLOAT_BE(ptr,val) duk_raw_writeinc_float_be(&(ptr), (duk_float_t) (val))
-#define DUK_RAW_WRITEINC_DOUBLE_BE(ptr,val) duk_raw_writeinc_double_be(&(ptr), (duk_double_t) (val))
-#define DUK_RAW_WRITEINC_XUTF8(ptr,val) duk_raw_writeinc_xutf8(&(ptr), (duk_ucodepoint_t) (val))
-#define DUK_RAW_WRITEINC_CESU8(ptr,val) duk_raw_writeinc_cesu8(&(ptr), (duk_ucodepoint_t) (val))
+#define DUK_RAW_WRITEINC_U16_BE(ptr, val)    duk_raw_writeinc_u16_be(&(ptr), (duk_uint16_t) (val))
+#define DUK_RAW_WRITEINC_U32_BE(ptr, val)    duk_raw_writeinc_u32_be(&(ptr), (duk_uint32_t) (val))
+#define DUK_RAW_WRITEINC_FLOAT_BE(ptr, val)  duk_raw_writeinc_float_be(&(ptr), (duk_float_t) (val))
+#define DUK_RAW_WRITEINC_DOUBLE_BE(ptr, val) duk_raw_writeinc_double_be(&(ptr), (duk_double_t) (val))
+#define DUK_RAW_WRITEINC_XUTF8(ptr, val)     duk_raw_writeinc_xutf8(&(ptr), (duk_ucodepoint_t) (val))
+#define DUK_RAW_WRITEINC_CESU8(ptr, val)     duk_raw_writeinc_cesu8(&(ptr), (duk_ucodepoint_t) (val))
 
-#define DUK_RAW_READ_U8(ptr) ((duk_uint8_t) (*(ptr)))
-#define DUK_RAW_READ_U16_BE(ptr) duk_raw_read_u16_be((ptr));
-#define DUK_RAW_READ_U32_BE(ptr) duk_raw_read_u32_be((ptr));
+#define DUK_RAW_READ_U8(ptr)        ((duk_uint8_t) (*(ptr)))
+#define DUK_RAW_READ_U16_BE(ptr)    duk_raw_read_u16_be((ptr));
+#define DUK_RAW_READ_U32_BE(ptr)    duk_raw_read_u32_be((ptr));
 #define DUK_RAW_READ_DOUBLE_BE(ptr) duk_raw_read_double_be((ptr));
 
-#define DUK_RAW_READINC_U8(ptr) ((duk_uint8_t) (*(ptr)++))
-#define DUK_RAW_READINC_U16_BE(ptr) duk_raw_readinc_u16_be(&(ptr));
-#define DUK_RAW_READINC_U32_BE(ptr) duk_raw_readinc_u32_be(&(ptr));
+#define DUK_RAW_READINC_U8(ptr)        ((duk_uint8_t) (*(ptr)++))
+#define DUK_RAW_READINC_U16_BE(ptr)    duk_raw_readinc_u16_be(&(ptr));
+#define DUK_RAW_READINC_U32_BE(ptr)    duk_raw_readinc_u32_be(&(ptr));
 #define DUK_RAW_READINC_DOUBLE_BE(ptr) duk_raw_readinc_double_be(&(ptr));
 
 /*
@@ -2475,29 +2511,31 @@
 };
 
 #if defined(DUK_USE_PREFER_SIZE)
-#define DUK_BW_SLACK_ADD           64
-#define DUK_BW_SLACK_SHIFT         4    /* 2^4 -> 1/16 = 6.25% slack */
+#define DUK_BW_SLACK_ADD   64
+#define DUK_BW_SLACK_SHIFT 4 /* 2^4 -> 1/16 = 6.25% slack */
 #else
-#define DUK_BW_SLACK_ADD           64
-#define DUK_BW_SLACK_SHIFT         2    /* 2^2 -> 1/4 = 25% slack */
+#define DUK_BW_SLACK_ADD   64
+#define DUK_BW_SLACK_SHIFT 2 /* 2^2 -> 1/4 = 25% slack */
 #endif
 
 /* Initialization and finalization (compaction), converting to other types. */
 
-#define DUK_BW_INIT_PUSHBUF(thr,bw_ctx,sz) do { \
+#define DUK_BW_INIT_PUSHBUF(thr, bw_ctx, sz) \
+	do { \
 		duk_bw_init_pushbuf((thr), (bw_ctx), (sz)); \
 	} while (0)
-#define DUK_BW_INIT_WITHBUF(thr,bw_ctx,buf) do { \
+#define DUK_BW_INIT_WITHBUF(thr, bw_ctx, buf) \
+	do { \
 		duk_bw_init((thr), (bw_ctx), (buf)); \
 	} while (0)
-#define DUK_BW_COMPACT(thr,bw_ctx) do { \
+#define DUK_BW_COMPACT(thr, bw_ctx) \
+	do { \
 		/* Make underlying buffer compact to match DUK_BW_GET_SIZE(). */ \
 		duk_bw_compact((thr), (bw_ctx)); \
 	} while (0)
-#define DUK_BW_PUSH_AS_STRING(thr,bw_ctx) do { \
-		duk_push_lstring((thr), \
-		                 (const char *) (bw_ctx)->p_base, \
-		                 (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
+#define DUK_BW_PUSH_AS_STRING(thr, bw_ctx) \
+	do { \
+		duk_push_lstring((thr), (const char *) (bw_ctx)->p_base, (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
 	} while (0)
 
 /* Pointers may be NULL for a while when 'buf' size is zero and before any
@@ -2507,43 +2545,48 @@
  */
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_bw_assert_valid(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx);
-#define DUK_BW_ASSERT_VALID_EXPR(thr,bw_ctx)  (duk_bw_assert_valid((thr), (bw_ctx)))
-#define DUK_BW_ASSERT_VALID(thr,bw_ctx)  do { duk_bw_assert_valid((thr), (bw_ctx)); } while (0)
+#define DUK_BW_ASSERT_VALID_EXPR(thr, bw_ctx) (duk_bw_assert_valid((thr), (bw_ctx)))
+#define DUK_BW_ASSERT_VALID(thr, bw_ctx) \
+	do { \
+		duk_bw_assert_valid((thr), (bw_ctx)); \
+	} while (0)
 #else
-#define DUK_BW_ASSERT_VALID_EXPR(thr,bw_ctx)  DUK_ASSERT_EXPR(1)
-#define DUK_BW_ASSERT_VALID(thr,bw_ctx)  do {} while (0)
+#define DUK_BW_ASSERT_VALID_EXPR(thr, bw_ctx) DUK_ASSERT_EXPR(1)
+#define DUK_BW_ASSERT_VALID(thr, bw_ctx) \
+	do { \
+	} while (0)
 #endif
 
 /* Working with the pointer and current size. */
 
-#define DUK_BW_GET_PTR(thr,bw_ctx) \
-	((bw_ctx)->p)
-#define DUK_BW_SET_PTR(thr,bw_ctx,ptr) do { \
+#define DUK_BW_GET_PTR(thr, bw_ctx) ((bw_ctx)->p)
+#define DUK_BW_SET_PTR(thr, bw_ctx, ptr) \
+	do { \
 		(bw_ctx)->p = (ptr); \
 	} while (0)
-#define DUK_BW_ADD_PTR(thr,bw_ctx,delta) do { \
+#define DUK_BW_ADD_PTR(thr, bw_ctx, delta) \
+	do { \
 		(bw_ctx)->p += (delta); \
 	} while (0)
-#define DUK_BW_GET_BASEPTR(thr,bw_ctx) \
-	((bw_ctx)->p_base)
-#define DUK_BW_GET_LIMITPTR(thr,bw_ctx) \
-	((bw_ctx)->p_limit)
-#define DUK_BW_GET_SIZE(thr,bw_ctx) \
-	((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base))
-#define DUK_BW_SET_SIZE(thr,bw_ctx,sz) do { \
+#define DUK_BW_GET_BASEPTR(thr, bw_ctx)  ((bw_ctx)->p_base)
+#define DUK_BW_GET_LIMITPTR(thr, bw_ctx) ((bw_ctx)->p_limit)
+#define DUK_BW_GET_SIZE(thr, bw_ctx)     ((duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base))
+#define DUK_BW_SET_SIZE(thr, bw_ctx, sz) \
+	do { \
 		DUK_ASSERT((duk_size_t) (sz) <= (duk_size_t) ((bw_ctx)->p - (bw_ctx)->p_base)); \
 		(bw_ctx)->p = (bw_ctx)->p_base + (sz); \
 	} while (0)
-#define DUK_BW_RESET_SIZE(thr,bw_ctx) do { \
+#define DUK_BW_RESET_SIZE(thr, bw_ctx) \
+	do { \
 		/* Reset to zero size, keep current limit. */ \
 		(bw_ctx)->p = (bw_ctx)->p_base; \
 	} while (0)
-#define DUK_BW_GET_BUFFER(thr,bw_ctx) \
-	((bw_ctx)->buf)
+#define DUK_BW_GET_BUFFER(thr, bw_ctx) ((bw_ctx)->buf)
 
 /* Ensuring (reserving) space. */
 
-#define DUK_BW_ENSURE(thr,bw_ctx,sz) do { \
+#define DUK_BW_ENSURE(thr, bw_ctx, sz) \
+	do { \
 		duk_size_t duk__sz, duk__space; \
 		DUK_BW_ASSERT_VALID((thr), (bw_ctx)); \
 		duk__sz = (sz); \
@@ -2554,22 +2597,21 @@
 	} while (0)
 /* NOTE: Multiple evaluation of 'ptr' in this macro. */
 /* XXX: Rework to use an always-inline function? */
-#define DUK_BW_ENSURE_RAW(thr,bw_ctx,sz,ptr) \
-	(((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? \
-	 (ptr) : \
-	 ((bw_ctx)->p = (ptr), duk_bw_resize((thr),(bw_ctx),(sz))))
-#define DUK_BW_ENSURE_GETPTR(thr,bw_ctx,sz) \
-	DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p)
-#define DUK_BW_ASSERT_SPACE_EXPR(thr,bw_ctx,sz) \
+#define DUK_BW_ENSURE_RAW(thr, bw_ctx, sz, ptr) \
+	(((duk_size_t) ((bw_ctx)->p_limit - (ptr)) >= (sz)) ? (ptr) : ((bw_ctx)->p = (ptr), duk_bw_resize((thr), (bw_ctx), (sz))))
+#define DUK_BW_ENSURE_GETPTR(thr, bw_ctx, sz) DUK_BW_ENSURE_RAW((thr), (bw_ctx), (sz), (bw_ctx)->p)
+#define DUK_BW_ASSERT_SPACE_EXPR(thr, bw_ctx, sz) \
 	(DUK_BW_ASSERT_VALID_EXPR((thr), (bw_ctx)), \
 	 DUK_ASSERT_EXPR((duk_size_t) ((bw_ctx)->p_limit - (bw_ctx)->p) >= (duk_size_t) (sz)))
-#define DUK_BW_ASSERT_SPACE(thr,bw_ctx,sz) do { \
+#define DUK_BW_ASSERT_SPACE(thr, bw_ctx, sz) \
+	do { \
 		DUK_BW_ASSERT_SPACE_EXPR((thr), (bw_ctx), (sz)); \
 	} while (0)
 
 /* Miscellaneous. */
 
-#define DUK_BW_SETPTR_AND_COMPACT(thr,bw_ctx,ptr) do { \
+#define DUK_BW_SETPTR_AND_COMPACT(thr, bw_ctx, ptr) \
+	do { \
 		(bw_ctx)->p = (ptr); \
 		duk_bw_compact((thr), (bw_ctx)); \
 	} while (0)
@@ -2580,11 +2622,13 @@
  * explicit pointer load/stores get generated (e.g. gcc -Os).
  */
 
-#define DUK_BW_WRITE_RAW_U8(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_RAW_U8(thr, bw_ctx, val) \
+	do { \
 		DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 1); \
 		*(bw_ctx)->p++ = (duk_uint8_t) (val); \
 	} while (0)
-#define DUK_BW_WRITE_RAW_U8_2(thr,bw_ctx,val1,val2) do { \
+#define DUK_BW_WRITE_RAW_U8_2(thr, bw_ctx, val1, val2) \
+	do { \
 		duk_uint8_t *duk__p; \
 		DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 2); \
 		duk__p = (bw_ctx)->p; \
@@ -2592,7 +2636,8 @@
 		*duk__p++ = (duk_uint8_t) (val2); \
 		(bw_ctx)->p = duk__p; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_U8_3(thr,bw_ctx,val1,val2,val3) do { \
+#define DUK_BW_WRITE_RAW_U8_3(thr, bw_ctx, val1, val2, val3) \
+	do { \
 		duk_uint8_t *duk__p; \
 		DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 3); \
 		duk__p = (bw_ctx)->p; \
@@ -2601,7 +2646,8 @@
 		*duk__p++ = (duk_uint8_t) (val3); \
 		(bw_ctx)->p = duk__p; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \
+#define DUK_BW_WRITE_RAW_U8_4(thr, bw_ctx, val1, val2, val3, val4) \
+	do { \
 		duk_uint8_t *duk__p; \
 		DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 4); \
 		duk__p = (bw_ctx)->p; \
@@ -2611,7 +2657,8 @@
 		*duk__p++ = (duk_uint8_t) (val4); \
 		(bw_ctx)->p = duk__p; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \
+#define DUK_BW_WRITE_RAW_U8_5(thr, bw_ctx, val1, val2, val3, val4, val5) \
+	do { \
 		duk_uint8_t *duk__p; \
 		DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 5); \
 		duk__p = (bw_ctx)->p; \
@@ -2622,7 +2669,8 @@
 		*duk__p++ = (duk_uint8_t) (val5); \
 		(bw_ctx)->p = duk__p; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \
+#define DUK_BW_WRITE_RAW_U8_6(thr, bw_ctx, val1, val2, val3, val4, val5, val6) \
+	do { \
 		duk_uint8_t *duk__p; \
 		DUK_BW_ASSERT_SPACE((thr), (bw_ctx), 6); \
 		duk__p = (bw_ctx)->p; \
@@ -2634,7 +2682,8 @@
 		*duk__p++ = (duk_uint8_t) (val6); \
 		(bw_ctx)->p = duk__p; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_XUTF8(thr,bw_ctx,cp) do { \
+#define DUK_BW_WRITE_RAW_XUTF8(thr, bw_ctx, cp) \
+	do { \
 		duk_ucodepoint_t duk__cp; \
 		duk_small_int_t duk__enc_len; \
 		duk__cp = (duk_ucodepoint_t) (cp); \
@@ -2642,7 +2691,8 @@
 		duk__enc_len = duk_unicode_encode_xutf8(duk__cp, (bw_ctx)->p); \
 		(bw_ctx)->p += duk__enc_len; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_CESU8(thr,bw_ctx,cp) do { \
+#define DUK_BW_WRITE_RAW_CESU8(thr, bw_ctx, cp) \
+	do { \
 		duk_ucodepoint_t duk__cp; \
 		duk_small_int_t duk__enc_len; \
 		duk__cp = (duk_ucodepoint_t) (cp); \
@@ -2652,7 +2702,8 @@
 	} while (0)
 /* XXX: add temporary duk__p pointer here too; sharing */
 /* XXX: avoid unsafe variants */
-#define DUK_BW_WRITE_RAW_BYTES(thr,bw_ctx,valptr,valsz) do { \
+#define DUK_BW_WRITE_RAW_BYTES(thr, bw_ctx, valptr, valsz) \
+	do { \
 		const void *duk__valptr; \
 		duk_size_t duk__valsz; \
 		duk__valptr = (const void *) (valptr); \
@@ -2660,7 +2711,8 @@
 		duk_memcpy_unsafe((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
 		(bw_ctx)->p += duk__valsz; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_CSTRING(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_RAW_CSTRING(thr, bw_ctx, val) \
+	do { \
 		const duk_uint8_t *duk__val; \
 		duk_size_t duk__val_len; \
 		duk__val = (const duk_uint8_t *) (val); \
@@ -2668,93 +2720,107 @@
 		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_HSTRING(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_RAW_HSTRING(thr, bw_ctx, val) \
+	do { \
 		duk_size_t duk__val_len; \
 		duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
 		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_HBUFFER(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_RAW_HBUFFER(thr, bw_ctx, val) \
+	do { \
 		duk_size_t duk__val_len; \
 		duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
-		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
+		duk_memcpy_unsafe((void *) ((bw_ctx)->p), \
+		                  (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), \
+		                  duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_RAW_HBUFFER_FIXED(thr, bw_ctx, val) \
+	do { \
 		duk_size_t duk__val_len; \
 		duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
-		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
+		duk_memcpy_unsafe((void *) ((bw_ctx)->p), \
+		                  (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), \
+		                  duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
-#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_RAW_HBUFFER_DYNAMIC(thr, bw_ctx, val) \
+	do { \
 		duk_size_t duk__val_len; \
 		duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
-		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
+		duk_memcpy_unsafe((void *) ((bw_ctx)->p), \
+		                  (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), \
+		                  duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
 
 /* Append bytes from a slice already in the buffer. */
-#define DUK_BW_WRITE_RAW_SLICE(thr,bw,dst_off,dst_len) \
-	duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len))
+#define DUK_BW_WRITE_RAW_SLICE(thr, bw, dst_off, dst_len) duk_bw_write_raw_slice((thr), (bw), (dst_off), (dst_len))
 
 /* Insert bytes in the middle of the buffer from an external buffer. */
-#define DUK_BW_INSERT_RAW_BYTES(thr,bw,dst_off,buf,len) \
-	duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len))
+#define DUK_BW_INSERT_RAW_BYTES(thr, bw, dst_off, buf, len) duk_bw_insert_raw_bytes((thr), (bw), (dst_off), (buf), (len))
 
 /* Insert bytes in the middle of the buffer from a slice already
  * in the buffer.  Source offset is interpreted "before" the operation.
  */
-#define DUK_BW_INSERT_RAW_SLICE(thr,bw,dst_off,src_off,len) \
-	duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len))
+#define DUK_BW_INSERT_RAW_SLICE(thr, bw, dst_off, src_off, len) duk_bw_insert_raw_slice((thr), (bw), (dst_off), (src_off), (len))
 
 /* Insert a reserved area somewhere in the buffer; caller fills it.
  * Evaluates to a (duk_uint_t *) pointing to the start of the reserved
  * area for convenience.
  */
-#define DUK_BW_INSERT_RAW_AREA(thr,bw,off,len) \
-	duk_bw_insert_raw_area((thr), (bw), (off), (len))
+#define DUK_BW_INSERT_RAW_AREA(thr, bw, off, len) duk_bw_insert_raw_area((thr), (bw), (off), (len))
 
 /* Remove a slice from inside buffer. */
-#define DUK_BW_REMOVE_RAW_SLICE(thr,bw,off,len) \
-	duk_bw_remove_raw_slice((thr), (bw), (off), (len))
+#define DUK_BW_REMOVE_RAW_SLICE(thr, bw, off, len) duk_bw_remove_raw_slice((thr), (bw), (off), (len))
 
 /* Safe write calls which will ensure space first. */
 
-#define DUK_BW_WRITE_ENSURE_U8(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_ENSURE_U8(thr, bw_ctx, val) \
+	do { \
 		DUK_BW_ENSURE((thr), (bw_ctx), 1); \
 		DUK_BW_WRITE_RAW_U8((thr), (bw_ctx), (val)); \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_U8_2(thr,bw_ctx,val1,val2) do { \
+#define DUK_BW_WRITE_ENSURE_U8_2(thr, bw_ctx, val1, val2) \
+	do { \
 		DUK_BW_ENSURE((thr), (bw_ctx), 2); \
 		DUK_BW_WRITE_RAW_U8_2((thr), (bw_ctx), (val1), (val2)); \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_U8_3(thr,bw_ctx,val1,val2,val3) do { \
+#define DUK_BW_WRITE_ENSURE_U8_3(thr, bw_ctx, val1, val2, val3) \
+	do { \
 		DUK_BW_ENSURE((thr), (bw_ctx), 3); \
 		DUK_BW_WRITE_RAW_U8_3((thr), (bw_ctx), (val1), (val2), (val3)); \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_U8_4(thr,bw_ctx,val1,val2,val3,val4) do { \
+#define DUK_BW_WRITE_ENSURE_U8_4(thr, bw_ctx, val1, val2, val3, val4) \
+	do { \
 		DUK_BW_ENSURE((thr), (bw_ctx), 4); \
 		DUK_BW_WRITE_RAW_U8_4((thr), (bw_ctx), (val1), (val2), (val3), (val4)); \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_U8_5(thr,bw_ctx,val1,val2,val3,val4,val5) do { \
+#define DUK_BW_WRITE_ENSURE_U8_5(thr, bw_ctx, val1, val2, val3, val4, val5) \
+	do { \
 		DUK_BW_ENSURE((thr), (bw_ctx), 5); \
 		DUK_BW_WRITE_RAW_U8_5((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5)); \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_U8_6(thr,bw_ctx,val1,val2,val3,val4,val5,val6) do { \
+#define DUK_BW_WRITE_ENSURE_U8_6(thr, bw_ctx, val1, val2, val3, val4, val5, val6) \
+	do { \
 		DUK_BW_ENSURE((thr), (bw_ctx), 6); \
 		DUK_BW_WRITE_RAW_U8_6((thr), (bw_ctx), (val1), (val2), (val3), (val4), (val5), (val6)); \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_XUTF8(thr,bw_ctx,cp) do { \
+#define DUK_BW_WRITE_ENSURE_XUTF8(thr, bw_ctx, cp) \
+	do { \
 		DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_XUTF8_LENGTH); \
 		DUK_BW_WRITE_RAW_XUTF8((thr), (bw_ctx), (cp)); \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_CESU8(thr,bw_ctx,cp) do { \
+#define DUK_BW_WRITE_ENSURE_CESU8(thr, bw_ctx, cp) \
+	do { \
 		DUK_BW_ENSURE((thr), (bw_ctx), DUK_UNICODE_MAX_CESU8_LENGTH); \
 		DUK_BW_WRITE_RAW_CESU8((thr), (bw_ctx), (cp)); \
 	} while (0)
 /* XXX: add temporary duk__p pointer here too; sharing */
 /* XXX: avoid unsafe */
-#define DUK_BW_WRITE_ENSURE_BYTES(thr,bw_ctx,valptr,valsz) do { \
+#define DUK_BW_WRITE_ENSURE_BYTES(thr, bw_ctx, valptr, valsz) \
+	do { \
 		const void *duk__valptr; \
 		duk_size_t duk__valsz; \
 		duk__valptr = (const void *) (valptr); \
@@ -2763,7 +2829,8 @@
 		duk_memcpy_unsafe((void *) ((bw_ctx)->p), duk__valptr, duk__valsz); \
 		(bw_ctx)->p += duk__valsz; \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_CSTRING(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_ENSURE_CSTRING(thr, bw_ctx, val) \
+	do { \
 		const duk_uint8_t *duk__val; \
 		duk_size_t duk__val_len; \
 		duk__val = (const duk_uint8_t *) (val); \
@@ -2772,45 +2839,53 @@
 		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) duk__val, duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_HSTRING(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_ENSURE_HSTRING(thr, bw_ctx, val) \
+	do { \
 		duk_size_t duk__val_len; \
 		duk__val_len = DUK_HSTRING_GET_BYTELEN((val)); \
 		DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
 		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) DUK_HSTRING_GET_DATA((val)), duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_HBUFFER(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_ENSURE_HBUFFER(thr, bw_ctx, val) \
+	do { \
 		duk_size_t duk__val_len; \
 		duk__val_len = DUK_HBUFFER_GET_SIZE((val)); \
 		DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
-		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
+		duk_memcpy_unsafe((void *) ((bw_ctx)->p), \
+		                  (const void *) DUK_HBUFFER_GET_DATA_PTR((thr)->heap, (val)), \
+		                  duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_ENSURE_HBUFFER_FIXED(thr, bw_ctx, val) \
+	do { \
 		duk_size_t duk__val_len; \
 		duk__val_len = DUK_HBUFFER_FIXED_GET_SIZE((val)); \
 		DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
-		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
+		duk_memcpy_unsafe((void *) ((bw_ctx)->p), \
+		                  (const void *) DUK_HBUFFER_FIXED_GET_DATA_PTR((thr)->heap, (val)), \
+		                  duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
-#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr,bw_ctx,val) do { \
+#define DUK_BW_WRITE_ENSURE_HBUFFER_DYNAMIC(thr, bw_ctx, val) \
+	do { \
 		duk_size_t duk__val_len; \
 		duk__val_len = DUK_HBUFFER_DYNAMIC_GET_SIZE((val)); \
 		DUK_BW_ENSURE((thr), (bw_ctx), duk__val_len); \
-		duk_memcpy_unsafe((void *) ((bw_ctx)->p), (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), duk__val_len); \
+		duk_memcpy_unsafe((void *) ((bw_ctx)->p), \
+		                  (const void *) DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((thr)->heap, (val)), \
+		                  duk__val_len); \
 		(bw_ctx)->p += duk__val_len; \
 	} while (0)
 
-#define DUK_BW_WRITE_ENSURE_SLICE(thr,bw,dst_off,dst_len) \
-	duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len))
-#define DUK_BW_INSERT_ENSURE_BYTES(thr,bw,dst_off,buf,len) \
-	duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len))
-#define DUK_BW_INSERT_ENSURE_SLICE(thr,bw,dst_off,src_off,len) \
+#define DUK_BW_WRITE_ENSURE_SLICE(thr, bw, dst_off, dst_len)   duk_bw_write_ensure_slice((thr), (bw), (dst_off), (dst_len))
+#define DUK_BW_INSERT_ENSURE_BYTES(thr, bw, dst_off, buf, len) duk_bw_insert_ensure_bytes((thr), (bw), (dst_off), (buf), (len))
+#define DUK_BW_INSERT_ENSURE_SLICE(thr, bw, dst_off, src_off, len) \
 	duk_bw_insert_ensure_slice((thr), (bw), (dst_off), (src_off), (len))
-#define DUK_BW_INSERT_ENSURE_AREA(thr,bw,off,len) \
+#define DUK_BW_INSERT_ENSURE_AREA(thr, bw, off, len) \
 	/* Evaluates to (duk_uint8_t *) pointing to start of area. */ \
 	duk_bw_insert_ensure_area((thr), (bw), (off), (len))
-#define DUK_BW_REMOVE_ENSURE_SLICE(thr,bw,off,len) \
+#define DUK_BW_REMOVE_ENSURE_SLICE(thr, bw, off, len) \
 	/* No difference between raw/ensure because the buffer shrinks. */ \
 	DUK_BW_REMOVE_RAW_SLICE((thr), (bw), (off), (len))
 
@@ -2826,13 +2901,13 @@
 DUK_INTERNAL_DECL const duk_int16_t duk_hex_dectab_shift4[256];
 DUK_INTERNAL_DECL const duk_uint16_t duk_hex_enctab[256];
 #endif
-#endif  /* !DUK_SINGLE_FILE */
+#endif /* !DUK_SINGLE_FILE */
 
 /* Note: assumes that duk_util_probe_steps size is 32 */
 #if defined(DUK_USE_HOBJECT_HASH_PART)
 #if !defined(DUK_SINGLE_FILE)
 DUK_INTERNAL_DECL duk_uint8_t duk_util_probe_steps[32];
-#endif  /* !DUK_SINGLE_FILE */
+#endif /* !DUK_SINGLE_FILE */
 #endif
 
 #if defined(DUK_USE_STRHASH_DENSE)
@@ -2860,10 +2935,26 @@
 DUK_INTERNAL_DECL void duk_bw_compact(duk_hthread *thr, duk_bufwriter_ctx *bw_ctx);
 DUK_INTERNAL_DECL void duk_bw_write_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len);
 DUK_INTERNAL_DECL void duk_bw_write_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t src_off, duk_size_t len);
-DUK_INTERNAL_DECL void duk_bw_insert_raw_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len);
-DUK_INTERNAL_DECL void duk_bw_insert_ensure_bytes(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, const duk_uint8_t *buf, duk_size_t len);
-DUK_INTERNAL_DECL void duk_bw_insert_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len);
-DUK_INTERNAL_DECL void duk_bw_insert_ensure_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t dst_off, duk_size_t src_off, duk_size_t len);
+DUK_INTERNAL_DECL void duk_bw_insert_raw_bytes(duk_hthread *thr,
+                                               duk_bufwriter_ctx *bw,
+                                               duk_size_t dst_off,
+                                               const duk_uint8_t *buf,
+                                               duk_size_t len);
+DUK_INTERNAL_DECL void duk_bw_insert_ensure_bytes(duk_hthread *thr,
+                                                  duk_bufwriter_ctx *bw,
+                                                  duk_size_t dst_off,
+                                                  const duk_uint8_t *buf,
+                                                  duk_size_t len);
+DUK_INTERNAL_DECL void duk_bw_insert_raw_slice(duk_hthread *thr,
+                                               duk_bufwriter_ctx *bw,
+                                               duk_size_t dst_off,
+                                               duk_size_t src_off,
+                                               duk_size_t len);
+DUK_INTERNAL_DECL void duk_bw_insert_ensure_slice(duk_hthread *thr,
+                                                  duk_bufwriter_ctx *bw,
+                                                  duk_size_t dst_off,
+                                                  duk_size_t src_off,
+                                                  duk_size_t len);
 DUK_INTERNAL_DECL duk_uint8_t *duk_bw_insert_raw_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len);
 DUK_INTERNAL_DECL duk_uint8_t *duk_bw_insert_ensure_area(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len);
 DUK_INTERNAL_DECL void duk_bw_remove_raw_slice(duk_hthread *thr, duk_bufwriter_ctx *bw, duk_size_t off, duk_size_t len);
@@ -2890,10 +2981,12 @@
 DUK_INTERNAL_DECL void duk_raw_writeinc_xutf8(duk_uint8_t **p, duk_ucodepoint_t val);
 DUK_INTERNAL_DECL void duk_raw_writeinc_cesu8(duk_uint8_t **p, duk_ucodepoint_t val);
 
-#if defined(DUK_USE_DEBUGGER_SUPPORT)  /* For now only needed by the debugger. */
+#if defined(DUK_USE_DEBUGGER_SUPPORT) /* For now only needed by the debugger. */
 DUK_INTERNAL_DECL void duk_byteswap_bytes(duk_uint8_t *p, duk_small_uint_t len);
 #endif
 
+DUK_INTERNAL_DECL duk_double_t duk_util_get_random_double(duk_hthread *thr);
+
 /* memcpy(), memmove() etc wrappers.  The plain variants like duk_memcpy()
  * assume C99+ and 'src' and 'dst' pointers must be non-NULL even when the
  * operation size is zero.  The unsafe variants like duk_memcpy_safe() deal
@@ -2904,7 +2997,8 @@
  * few extra bytes per call site adds up to ~1kB footprint.
  */
 #if defined(DUK_USE_ALLOW_UNDEFINED_BEHAVIOR)
-#define duk_memcpy(dst,src,len)  do { \
+#define duk_memcpy(dst, src, len) \
+	do { \
 		void *duk__dst = (dst); \
 		const void *duk__src = (src); \
 		duk_size_t duk__len = (len); \
@@ -2912,8 +3006,9 @@
 		DUK_ASSERT(duk__src != NULL || duk__len == 0U); \
 		(void) DUK_MEMCPY(duk__dst, duk__src, (size_t) duk__len); \
 	} while (0)
-#define duk_memcpy_unsafe(dst,src,len)  duk_memcpy((dst), (src), (len))
-#define duk_memmove(dst,src,len)  do { \
+#define duk_memcpy_unsafe(dst, src, len) duk_memcpy((dst), (src), (len))
+#define duk_memmove(dst, src, len) \
+	do { \
 		void *duk__dst = (dst); \
 		const void *duk__src = (src); \
 		duk_size_t duk__len = (len); \
@@ -2921,24 +3016,27 @@
 		DUK_ASSERT(duk__src != NULL || duk__len == 0U); \
 		(void) DUK_MEMMOVE(duk__dst, duk__src, (size_t) duk__len); \
 	} while (0)
-#define duk_memmove_unsafe(dst,src,len)  duk_memmove((dst), (src), (len))
-#define duk_memset(dst,val,len)  do { \
+#define duk_memmove_unsafe(dst, src, len) duk_memmove((dst), (src), (len))
+#define duk_memset(dst, val, len) \
+	do { \
 		void *duk__dst = (dst); \
 		duk_small_int_t duk__val = (val); \
 		duk_size_t duk__len = (len); \
 		DUK_ASSERT(duk__dst != NULL || duk__len == 0U); \
 		(void) DUK_MEMSET(duk__dst, duk__val, (size_t) duk__len); \
 	} while (0)
-#define duk_memset_unsafe(dst,val,len)  duk_memset((dst), (val), (len))
-#define duk_memzero(dst,len)  do { \
+#define duk_memset_unsafe(dst, val, len) duk_memset((dst), (val), (len))
+#define duk_memzero(dst, len) \
+	do { \
 		void *duk__dst = (dst); \
 		duk_size_t duk__len = (len); \
 		DUK_ASSERT(duk__dst != NULL || duk__len == 0U); \
 		(void) DUK_MEMZERO(duk__dst, (size_t) duk__len); \
 	} while (0)
-#define duk_memzero_unsafe(dst,len)  duk_memzero((dst), (len))
-#else  /* DUK_USE_ALLOW_UNDEFINED_BEHAVIOR */
-#define duk_memcpy(dst,src,len)  do { \
+#define duk_memzero_unsafe(dst, len) duk_memzero((dst), (len))
+#else /* DUK_USE_ALLOW_UNDEFINED_BEHAVIOR */
+#define duk_memcpy(dst, src, len) \
+	do { \
 		void *duk__dst = (dst); \
 		const void *duk__src = (src); \
 		duk_size_t duk__len = (len); \
@@ -2946,7 +3044,8 @@
 		DUK_ASSERT(duk__src != NULL); \
 		(void) DUK_MEMCPY(duk__dst, duk__src, (size_t) duk__len); \
 	} while (0)
-#define duk_memcpy_unsafe(dst,src,len)  do { \
+#define duk_memcpy_unsafe(dst, src, len) \
+	do { \
 		void *duk__dst = (dst); \
 		const void *duk__src = (src); \
 		duk_size_t duk__len = (len); \
@@ -2958,7 +3057,8 @@
 			(void) DUK_MEMCPY(duk__dst, duk__src, (size_t) duk__len); \
 		} \
 	} while (0)
-#define duk_memmove(dst,src,len)  do { \
+#define duk_memmove(dst, src, len) \
+	do { \
 		void *duk__dst = (dst); \
 		const void *duk__src = (src); \
 		duk_size_t duk__len = (len); \
@@ -2966,7 +3066,8 @@
 		DUK_ASSERT(duk__src != NULL); \
 		(void) DUK_MEMMOVE(duk__dst, duk__src, (size_t) duk__len); \
 	} while (0)
-#define duk_memmove_unsafe(dst,src,len)  do { \
+#define duk_memmove_unsafe(dst, src, len) \
+	do { \
 		void *duk__dst = (dst); \
 		const void *duk__src = (src); \
 		duk_size_t duk__len = (len); \
@@ -2978,14 +3079,16 @@
 			(void) DUK_MEMMOVE(duk__dst, duk__src, (size_t) duk__len); \
 		} \
 	} while (0)
-#define duk_memset(dst,val,len)  do { \
+#define duk_memset(dst, val, len) \
+	do { \
 		void *duk__dst = (dst); \
 		duk_small_int_t duk__val = (val); \
 		duk_size_t duk__len = (len); \
 		DUK_ASSERT(duk__dst != NULL); \
 		(void) DUK_MEMSET(duk__dst, duk__val, (size_t) duk__len); \
 	} while (0)
-#define duk_memset_unsafe(dst,val,len)  do { \
+#define duk_memset_unsafe(dst, val, len) \
+	do { \
 		void *duk__dst = (dst); \
 		duk_small_int_t duk__val = (val); \
 		duk_size_t duk__len = (len); \
@@ -2995,13 +3098,15 @@
 			(void) DUK_MEMSET(duk__dst, duk__val, (size_t) duk__len); \
 		} \
 	} while (0)
-#define duk_memzero(dst,len)  do { \
+#define duk_memzero(dst, len) \
+	do { \
 		void *duk__dst = (dst); \
 		duk_size_t duk__len = (len); \
 		DUK_ASSERT(duk__dst != NULL); \
 		(void) DUK_MEMZERO(duk__dst, (size_t) duk__len); \
 	} while (0)
-#define duk_memzero_unsafe(dst,len)  do { \
+#define duk_memzero_unsafe(dst, len) \
+	do { \
 		void *duk__dst = (dst); \
 		duk_size_t duk__len = (len); \
 		DUK_ASSERT(duk__dst != NULL || duk__len == 0U); \
@@ -3010,7 +3115,7 @@
 			(void) DUK_MEMZERO(duk__dst, (size_t) duk__len); \
 		} \
 	} while (0)
-#endif  /* DUK_USE_ALLOW_UNDEFINED_BEHAVIOR */
+#endif /* DUK_USE_ALLOW_UNDEFINED_BEHAVIOR */
 
 DUK_INTERNAL_DECL duk_small_int_t duk_memcmp(const void *s1, const void *s2, duk_size_t len);
 DUK_INTERNAL_DECL duk_small_int_t duk_memcmp_unsafe(const void *s1, const void *s2, duk_size_t len);
@@ -3056,10 +3161,9 @@
  *
  * However, incorrectly true for x == 0 so check for that explicitly.
  */
-#define DUK_IS_POWER_OF_TWO(x) \
-	((x) != 0U && ((x) & ((x) - 1U)) == 0U)
+#define DUK_IS_POWER_OF_TWO(x) ((x) != 0U && ((x) & ((x) -1U)) == 0U)
 
-#endif  /* DUK_UTIL_H_INCLUDED */
+#endif /* DUK_UTIL_H_INCLUDED */
 /* #include duk_strings.h */
 #line 1 "duk_strings.h"
 /*
@@ -3086,151 +3190,151 @@
 #define DUK_ERRMSG_H_INCLUDED
 
 /* Mostly API and built-in method related */
-#define DUK_STR_INTERNAL_ERROR                   "internal error"
-#define DUK_STR_UNSUPPORTED                      "unsupported"
-#define DUK_STR_INVALID_COUNT                    "invalid count"
-#define DUK_STR_INVALID_ARGS                     "invalid args"
-#define DUK_STR_INVALID_STATE                    "invalid state"
-#define DUK_STR_INVALID_INPUT                    "invalid input"
-#define DUK_STR_INVALID_LENGTH                   "invalid length"
-#define DUK_STR_NOT_CONSTRUCTABLE                "not constructable"
-#define DUK_STR_CONSTRUCT_ONLY                   "constructor requires 'new'"
-#define DUK_STR_NOT_CALLABLE                     "not callable"
-#define DUK_STR_NOT_EXTENSIBLE                   "not extensible"
-#define DUK_STR_NOT_WRITABLE                     "not writable"
-#define DUK_STR_NOT_CONFIGURABLE                 "not configurable"
-#define DUK_STR_INVALID_CONTEXT                  "invalid context"
-#define DUK_STR_INVALID_INDEX                    "invalid args"
-#define DUK_STR_PUSH_BEYOND_ALLOC_STACK          "cannot push beyond allocated stack"
-#define DUK_STR_NOT_UNDEFINED                    "unexpected type"
-#define DUK_STR_NOT_NULL                         "unexpected type"
-#define DUK_STR_NOT_BOOLEAN                      "unexpected type"
-#define DUK_STR_NOT_NUMBER                       "unexpected type"
-#define DUK_STR_NOT_STRING                       "unexpected type"
-#define DUK_STR_NOT_OBJECT                       "unexpected type"
-#define DUK_STR_NOT_POINTER                      "unexpected type"
-#define DUK_STR_NOT_BUFFER                       "not buffer"  /* still in use with verbose messages */
-#define DUK_STR_UNEXPECTED_TYPE                  "unexpected type"
-#define DUK_STR_NOT_THREAD                       "unexpected type"
-#define DUK_STR_NOT_COMPFUNC                     "unexpected type"
-#define DUK_STR_NOT_NATFUNC                      "unexpected type"
-#define DUK_STR_NOT_C_FUNCTION                   "unexpected type"
-#define DUK_STR_NOT_FUNCTION                     "unexpected type"
-#define DUK_STR_NOT_REGEXP                       "unexpected type"
-#define DUK_STR_TOPRIMITIVE_FAILED               "coercion to primitive failed"
-#define DUK_STR_NUMBER_OUTSIDE_RANGE             "number outside range"
-#define DUK_STR_NOT_OBJECT_COERCIBLE             "not object coercible"
-#define DUK_STR_CANNOT_NUMBER_COERCE_SYMBOL      "cannot number coerce Symbol"
-#define DUK_STR_CANNOT_STRING_COERCE_SYMBOL      "cannot string coerce Symbol"
-#define DUK_STR_STRING_TOO_LONG                  "string too long"
-#define DUK_STR_BUFFER_TOO_LONG                  "buffer too long"
-#define DUK_STR_ALLOC_FAILED                     "alloc failed"
-#define DUK_STR_WRONG_BUFFER_TYPE                "wrong buffer type"
-#define DUK_STR_BASE64_ENCODE_FAILED             "base64 encode failed"
-#define DUK_STR_SOURCE_DECODE_FAILED             "source decode failed"
-#define DUK_STR_UTF8_DECODE_FAILED               "utf-8 decode failed"
-#define DUK_STR_BASE64_DECODE_FAILED             "base64 decode failed"
-#define DUK_STR_HEX_DECODE_FAILED                "hex decode failed"
-#define DUK_STR_INVALID_BYTECODE                 "invalid bytecode"
-#define DUK_STR_NO_SOURCECODE                    "no sourcecode"
-#define DUK_STR_RESULT_TOO_LONG                  "result too long"
-#define DUK_STR_INVALID_CFUNC_RC                 "invalid C function rc"
-#define DUK_STR_INVALID_INSTANCEOF_RVAL          "invalid instanceof rval"
-#define DUK_STR_INVALID_INSTANCEOF_RVAL_NOPROTO  "instanceof rval has no .prototype"
+#define DUK_STR_INTERNAL_ERROR                  "internal error"
+#define DUK_STR_UNSUPPORTED                     "unsupported"
+#define DUK_STR_INVALID_COUNT                   "invalid count"
+#define DUK_STR_INVALID_ARGS                    "invalid args"
+#define DUK_STR_INVALID_STATE                   "invalid state"
+#define DUK_STR_INVALID_INPUT                   "invalid input"
+#define DUK_STR_INVALID_LENGTH                  "invalid length"
+#define DUK_STR_NOT_CONSTRUCTABLE               "not constructable"
+#define DUK_STR_CONSTRUCT_ONLY                  "constructor requires 'new'"
+#define DUK_STR_NOT_CALLABLE                    "not callable"
+#define DUK_STR_NOT_EXTENSIBLE                  "not extensible"
+#define DUK_STR_NOT_WRITABLE                    "not writable"
+#define DUK_STR_NOT_CONFIGURABLE                "not configurable"
+#define DUK_STR_INVALID_CONTEXT                 "invalid context"
+#define DUK_STR_INVALID_INDEX                   "invalid args"
+#define DUK_STR_PUSH_BEYOND_ALLOC_STACK         "cannot push beyond allocated stack"
+#define DUK_STR_NOT_UNDEFINED                   "unexpected type"
+#define DUK_STR_NOT_NULL                        "unexpected type"
+#define DUK_STR_NOT_BOOLEAN                     "unexpected type"
+#define DUK_STR_NOT_NUMBER                      "unexpected type"
+#define DUK_STR_NOT_STRING                      "unexpected type"
+#define DUK_STR_NOT_OBJECT                      "unexpected type"
+#define DUK_STR_NOT_POINTER                     "unexpected type"
+#define DUK_STR_NOT_BUFFER                      "not buffer" /* still in use with verbose messages */
+#define DUK_STR_UNEXPECTED_TYPE                 "unexpected type"
+#define DUK_STR_NOT_THREAD                      "unexpected type"
+#define DUK_STR_NOT_COMPFUNC                    "unexpected type"
+#define DUK_STR_NOT_NATFUNC                     "unexpected type"
+#define DUK_STR_NOT_C_FUNCTION                  "unexpected type"
+#define DUK_STR_NOT_FUNCTION                    "unexpected type"
+#define DUK_STR_NOT_REGEXP                      "unexpected type"
+#define DUK_STR_TOPRIMITIVE_FAILED              "coercion to primitive failed"
+#define DUK_STR_NUMBER_OUTSIDE_RANGE            "number outside range"
+#define DUK_STR_NOT_OBJECT_COERCIBLE            "not object coercible"
+#define DUK_STR_CANNOT_NUMBER_COERCE_SYMBOL     "cannot number coerce Symbol"
+#define DUK_STR_CANNOT_STRING_COERCE_SYMBOL     "cannot string coerce Symbol"
+#define DUK_STR_STRING_TOO_LONG                 "string too long"
+#define DUK_STR_BUFFER_TOO_LONG                 "buffer too long"
+#define DUK_STR_ALLOC_FAILED                    "alloc failed"
+#define DUK_STR_WRONG_BUFFER_TYPE               "wrong buffer type"
+#define DUK_STR_BASE64_ENCODE_FAILED            "base64 encode failed"
+#define DUK_STR_SOURCE_DECODE_FAILED            "source decode failed"
+#define DUK_STR_UTF8_DECODE_FAILED              "utf-8 decode failed"
+#define DUK_STR_BASE64_DECODE_FAILED            "base64 decode failed"
+#define DUK_STR_HEX_DECODE_FAILED               "hex decode failed"
+#define DUK_STR_INVALID_BYTECODE                "invalid bytecode"
+#define DUK_STR_NO_SOURCECODE                   "no sourcecode"
+#define DUK_STR_RESULT_TOO_LONG                 "result too long"
+#define DUK_STR_INVALID_CFUNC_RC                "invalid C function rc"
+#define DUK_STR_INVALID_INSTANCEOF_RVAL         "invalid instanceof rval"
+#define DUK_STR_INVALID_INSTANCEOF_RVAL_NOPROTO "instanceof rval has no .prototype"
 
 /* JSON */
-#define DUK_STR_FMT_PTR                          "%p"
-#define DUK_STR_FMT_INVALID_JSON                 "invalid json (at offset %ld)"
-#define DUK_STR_CYCLIC_INPUT                     "cyclic input"
+#define DUK_STR_FMT_PTR          "%p"
+#define DUK_STR_FMT_INVALID_JSON "invalid json (at offset %ld)"
+#define DUK_STR_CYCLIC_INPUT     "cyclic input"
 
 /* Generic codec */
-#define DUK_STR_DEC_RECLIMIT                     "decode recursion limit"
-#define DUK_STR_ENC_RECLIMIT                     "encode recursion limit"
+#define DUK_STR_DEC_RECLIMIT "decode recursion limit"
+#define DUK_STR_ENC_RECLIMIT "encode recursion limit"
 
 /* Object property access */
-#define DUK_STR_INVALID_BASE                     "invalid base value"
-#define DUK_STR_STRICT_CALLER_READ               "cannot read strict 'caller'"
-#define DUK_STR_PROXY_REJECTED                   "proxy rejected"
-#define DUK_STR_INVALID_ARRAY_LENGTH             "invalid array length"
-#define DUK_STR_SETTER_UNDEFINED                 "setter undefined"
-#define DUK_STR_INVALID_DESCRIPTOR               "invalid descriptor"
+#define DUK_STR_INVALID_BASE         "invalid base value"
+#define DUK_STR_STRICT_CALLER_READ   "cannot read strict 'caller'"
+#define DUK_STR_PROXY_REJECTED       "proxy rejected"
+#define DUK_STR_INVALID_ARRAY_LENGTH "invalid array length"
+#define DUK_STR_SETTER_UNDEFINED     "setter undefined"
+#define DUK_STR_INVALID_DESCRIPTOR   "invalid descriptor"
 
 /* Proxy */
-#define DUK_STR_PROXY_REVOKED                    "proxy revoked"
-#define DUK_STR_INVALID_TRAP_RESULT              "invalid trap result"
+#define DUK_STR_PROXY_REVOKED       "proxy revoked"
+#define DUK_STR_INVALID_TRAP_RESULT "invalid trap result"
 
 /* Variables */
 
 /* Lexer */
-#define DUK_STR_INVALID_ESCAPE                   "invalid escape"
-#define DUK_STR_UNTERMINATED_STRING              "unterminated string"
-#define DUK_STR_UNTERMINATED_COMMENT             "unterminated comment"
-#define DUK_STR_UNTERMINATED_REGEXP              "unterminated regexp"
-#define DUK_STR_TOKEN_LIMIT                      "token limit"
-#define DUK_STR_REGEXP_SUPPORT_DISABLED          "regexp support disabled"
-#define DUK_STR_INVALID_NUMBER_LITERAL           "invalid number literal"
-#define DUK_STR_INVALID_TOKEN                    "invalid token"
+#define DUK_STR_INVALID_ESCAPE          "invalid escape"
+#define DUK_STR_UNTERMINATED_STRING     "unterminated string"
+#define DUK_STR_UNTERMINATED_COMMENT    "unterminated comment"
+#define DUK_STR_UNTERMINATED_REGEXP     "unterminated regexp"
+#define DUK_STR_TOKEN_LIMIT             "token limit"
+#define DUK_STR_REGEXP_SUPPORT_DISABLED "regexp support disabled"
+#define DUK_STR_INVALID_NUMBER_LITERAL  "invalid number literal"
+#define DUK_STR_INVALID_TOKEN           "invalid token"
 
 /* Compiler */
-#define DUK_STR_PARSE_ERROR                      "parse error"
-#define DUK_STR_DUPLICATE_LABEL                  "duplicate label"
-#define DUK_STR_INVALID_LABEL                    "invalid label"
-#define DUK_STR_INVALID_ARRAY_LITERAL            "invalid array literal"
-#define DUK_STR_INVALID_OBJECT_LITERAL           "invalid object literal"
-#define DUK_STR_INVALID_VAR_DECLARATION          "invalid variable declaration"
-#define DUK_STR_CANNOT_DELETE_IDENTIFIER         "cannot delete identifier"
-#define DUK_STR_INVALID_EXPRESSION               "invalid expression"
-#define DUK_STR_INVALID_LVALUE                   "invalid lvalue"
-#define DUK_STR_INVALID_NEWTARGET                "invalid new.target"
-#define DUK_STR_EXPECTED_IDENTIFIER              "expected identifier"
-#define DUK_STR_EMPTY_EXPR_NOT_ALLOWED           "empty expression not allowed"
-#define DUK_STR_INVALID_FOR                      "invalid for statement"
-#define DUK_STR_INVALID_SWITCH                   "invalid switch statement"
-#define DUK_STR_INVALID_BREAK_CONT_LABEL         "invalid break/continue label"
-#define DUK_STR_INVALID_RETURN                   "invalid return"
-#define DUK_STR_INVALID_TRY                      "invalid try"
-#define DUK_STR_INVALID_THROW                    "invalid throw"
-#define DUK_STR_WITH_IN_STRICT_MODE              "with in strict mode"
-#define DUK_STR_FUNC_STMT_NOT_ALLOWED            "function statement not allowed"
-#define DUK_STR_UNTERMINATED_STMT                "unterminated statement"
-#define DUK_STR_INVALID_ARG_NAME                 "invalid argument name"
-#define DUK_STR_INVALID_FUNC_NAME                "invalid function name"
-#define DUK_STR_INVALID_GETSET_NAME              "invalid getter/setter name"
-#define DUK_STR_FUNC_NAME_REQUIRED               "function name required"
+#define DUK_STR_PARSE_ERROR              "parse error"
+#define DUK_STR_DUPLICATE_LABEL          "duplicate label"
+#define DUK_STR_INVALID_LABEL            "invalid label"
+#define DUK_STR_INVALID_ARRAY_LITERAL    "invalid array literal"
+#define DUK_STR_INVALID_OBJECT_LITERAL   "invalid object literal"
+#define DUK_STR_INVALID_VAR_DECLARATION  "invalid variable declaration"
+#define DUK_STR_CANNOT_DELETE_IDENTIFIER "cannot delete identifier"
+#define DUK_STR_INVALID_EXPRESSION       "invalid expression"
+#define DUK_STR_INVALID_LVALUE           "invalid lvalue"
+#define DUK_STR_INVALID_NEWTARGET        "invalid new.target"
+#define DUK_STR_EXPECTED_IDENTIFIER      "expected identifier"
+#define DUK_STR_EMPTY_EXPR_NOT_ALLOWED   "empty expression not allowed"
+#define DUK_STR_INVALID_FOR              "invalid for statement"
+#define DUK_STR_INVALID_SWITCH           "invalid switch statement"
+#define DUK_STR_INVALID_BREAK_CONT_LABEL "invalid break/continue label"
+#define DUK_STR_INVALID_RETURN           "invalid return"
+#define DUK_STR_INVALID_TRY              "invalid try"
+#define DUK_STR_INVALID_THROW            "invalid throw"
+#define DUK_STR_WITH_IN_STRICT_MODE      "with in strict mode"
+#define DUK_STR_FUNC_STMT_NOT_ALLOWED    "function statement not allowed"
+#define DUK_STR_UNTERMINATED_STMT        "unterminated statement"
+#define DUK_STR_INVALID_ARG_NAME         "invalid argument name"
+#define DUK_STR_INVALID_FUNC_NAME        "invalid function name"
+#define DUK_STR_INVALID_GETSET_NAME      "invalid getter/setter name"
+#define DUK_STR_FUNC_NAME_REQUIRED       "function name required"
 
 /* RegExp */
-#define DUK_STR_INVALID_QUANTIFIER               "invalid regexp quantifier"
-#define DUK_STR_INVALID_QUANTIFIER_NO_ATOM       "quantifier without preceding atom"
-#define DUK_STR_INVALID_QUANTIFIER_VALUES        "quantifier values invalid (qmin > qmax)"
-#define DUK_STR_QUANTIFIER_TOO_MANY_COPIES       "quantifier requires too many atom copies"
-#define DUK_STR_UNEXPECTED_CLOSING_PAREN         "unexpected closing parenthesis"
-#define DUK_STR_UNEXPECTED_END_OF_PATTERN        "unexpected end of pattern"
-#define DUK_STR_UNEXPECTED_REGEXP_TOKEN          "unexpected token in regexp"
-#define DUK_STR_INVALID_REGEXP_FLAGS             "invalid regexp flags"
-#define DUK_STR_INVALID_REGEXP_ESCAPE            "invalid regexp escape"
-#define DUK_STR_INVALID_BACKREFS                 "invalid backreference(s)"
-#define DUK_STR_INVALID_REGEXP_CHARACTER         "invalid regexp character"
-#define DUK_STR_INVALID_REGEXP_GROUP             "invalid regexp group"
-#define DUK_STR_UNTERMINATED_CHARCLASS           "unterminated character class"
-#define DUK_STR_INVALID_RANGE                    "invalid range"
+#define DUK_STR_INVALID_QUANTIFIER         "invalid regexp quantifier"
+#define DUK_STR_INVALID_QUANTIFIER_NO_ATOM "quantifier without preceding atom"
+#define DUK_STR_INVALID_QUANTIFIER_VALUES  "quantifier values invalid (qmin > qmax)"
+#define DUK_STR_QUANTIFIER_TOO_MANY_COPIES "quantifier requires too many atom copies"
+#define DUK_STR_UNEXPECTED_CLOSING_PAREN   "unexpected closing parenthesis"
+#define DUK_STR_UNEXPECTED_END_OF_PATTERN  "unexpected end of pattern"
+#define DUK_STR_UNEXPECTED_REGEXP_TOKEN    "unexpected token in regexp"
+#define DUK_STR_INVALID_REGEXP_FLAGS       "invalid regexp flags"
+#define DUK_STR_INVALID_REGEXP_ESCAPE      "invalid regexp escape"
+#define DUK_STR_INVALID_BACKREFS           "invalid backreference(s)"
+#define DUK_STR_INVALID_REGEXP_CHARACTER   "invalid regexp character"
+#define DUK_STR_INVALID_REGEXP_GROUP       "invalid regexp group"
+#define DUK_STR_UNTERMINATED_CHARCLASS     "unterminated character class"
+#define DUK_STR_INVALID_RANGE              "invalid range"
 
 /* Limits */
-#define DUK_STR_VALSTACK_LIMIT                   "valstack limit"
-#define DUK_STR_CALLSTACK_LIMIT                  "callstack limit"
-#define DUK_STR_PROTOTYPE_CHAIN_LIMIT            "prototype chain limit"
-#define DUK_STR_BOUND_CHAIN_LIMIT                "function call bound chain limit"
-#define DUK_STR_NATIVE_STACK_LIMIT               "C stack depth limit"
-#define DUK_STR_COMPILER_RECURSION_LIMIT         "compiler recursion limit"
-#define DUK_STR_BYTECODE_LIMIT                   "bytecode limit"
-#define DUK_STR_REG_LIMIT                        "register limit"
-#define DUK_STR_TEMP_LIMIT                       "temp limit"
-#define DUK_STR_CONST_LIMIT                      "const limit"
-#define DUK_STR_FUNC_LIMIT                       "function limit"
-#define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT  "regexp compiler recursion limit"
-#define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT  "regexp executor recursion limit"
-#define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT       "regexp step limit"
+#define DUK_STR_VALSTACK_LIMIT                  "valstack limit"
+#define DUK_STR_CALLSTACK_LIMIT                 "callstack limit"
+#define DUK_STR_PROTOTYPE_CHAIN_LIMIT           "prototype chain limit"
+#define DUK_STR_BOUND_CHAIN_LIMIT               "function call bound chain limit"
+#define DUK_STR_NATIVE_STACK_LIMIT              "C stack depth limit"
+#define DUK_STR_COMPILER_RECURSION_LIMIT        "compiler recursion limit"
+#define DUK_STR_BYTECODE_LIMIT                  "bytecode limit"
+#define DUK_STR_REG_LIMIT                       "register limit"
+#define DUK_STR_TEMP_LIMIT                      "temp limit"
+#define DUK_STR_CONST_LIMIT                     "const limit"
+#define DUK_STR_FUNC_LIMIT                      "function limit"
+#define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT "regexp compiler recursion limit"
+#define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT "regexp executor recursion limit"
+#define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT      "regexp step limit"
 
-#endif  /* DUK_ERRMSG_H_INCLUDED */
+#endif /* DUK_ERRMSG_H_INCLUDED */
 /* #include duk_js_bytecode.h */
 #line 1 "duk_js_bytecode.h"
 /*
@@ -3318,403 +3422,394 @@
 
 typedef duk_uint32_t duk_instr_t;
 
-#define DUK_BC_SHIFT_OP             0
-#define DUK_BC_SHIFT_A              8
-#define DUK_BC_SHIFT_B              16
-#define DUK_BC_SHIFT_C              24
-#define DUK_BC_SHIFT_BC             DUK_BC_SHIFT_B
-#define DUK_BC_SHIFT_ABC            DUK_BC_SHIFT_A
+#define DUK_BC_SHIFT_OP  0
+#define DUK_BC_SHIFT_A   8
+#define DUK_BC_SHIFT_B   16
+#define DUK_BC_SHIFT_C   24
+#define DUK_BC_SHIFT_BC  DUK_BC_SHIFT_B
+#define DUK_BC_SHIFT_ABC DUK_BC_SHIFT_A
 
-#define DUK_BC_UNSHIFTED_MASK_OP    0xffUL
-#define DUK_BC_UNSHIFTED_MASK_A     0xffUL
-#define DUK_BC_UNSHIFTED_MASK_B     0xffUL
-#define DUK_BC_UNSHIFTED_MASK_C     0xffUL
-#define DUK_BC_UNSHIFTED_MASK_BC    0xffffUL
-#define DUK_BC_UNSHIFTED_MASK_ABC   0xffffffUL
+#define DUK_BC_UNSHIFTED_MASK_OP  0xffUL
+#define DUK_BC_UNSHIFTED_MASK_A   0xffUL
+#define DUK_BC_UNSHIFTED_MASK_B   0xffUL
+#define DUK_BC_UNSHIFTED_MASK_C   0xffUL
+#define DUK_BC_UNSHIFTED_MASK_BC  0xffffUL
+#define DUK_BC_UNSHIFTED_MASK_ABC 0xffffffUL
 
-#define DUK_BC_SHIFTED_MASK_OP      (DUK_BC_UNSHIFTED_MASK_OP << DUK_BC_SHIFT_OP)
-#define DUK_BC_SHIFTED_MASK_A       (DUK_BC_UNSHIFTED_MASK_A << DUK_BC_SHIFT_A)
-#define DUK_BC_SHIFTED_MASK_B       (DUK_BC_UNSHIFTED_MASK_B << DUK_BC_SHIFT_B)
-#define DUK_BC_SHIFTED_MASK_C       (DUK_BC_UNSHIFTED_MASK_C << DUK_BC_SHIFT_C)
-#define DUK_BC_SHIFTED_MASK_BC      (DUK_BC_UNSHIFTED_MASK_BC << DUK_BC_SHIFT_BC)
-#define DUK_BC_SHIFTED_MASK_ABC     (DUK_BC_UNSHIFTED_MASK_ABC << DUK_BC_SHIFT_ABC)
+#define DUK_BC_SHIFTED_MASK_OP  (DUK_BC_UNSHIFTED_MASK_OP << DUK_BC_SHIFT_OP)
+#define DUK_BC_SHIFTED_MASK_A   (DUK_BC_UNSHIFTED_MASK_A << DUK_BC_SHIFT_A)
+#define DUK_BC_SHIFTED_MASK_B   (DUK_BC_UNSHIFTED_MASK_B << DUK_BC_SHIFT_B)
+#define DUK_BC_SHIFTED_MASK_C   (DUK_BC_UNSHIFTED_MASK_C << DUK_BC_SHIFT_C)
+#define DUK_BC_SHIFTED_MASK_BC  (DUK_BC_UNSHIFTED_MASK_BC << DUK_BC_SHIFT_BC)
+#define DUK_BC_SHIFTED_MASK_ABC (DUK_BC_UNSHIFTED_MASK_ABC << DUK_BC_SHIFT_ABC)
 
-#define DUK_DEC_OP(x)               ((x) & 0xffUL)
-#define DUK_DEC_A(x)                (((x) >> 8) & 0xffUL)
-#define DUK_DEC_B(x)                (((x) >> 16) & 0xffUL)
-#define DUK_DEC_C(x)                (((x) >> 24) & 0xffUL)
-#define DUK_DEC_BC(x)               (((x) >> 16) & 0xffffUL)
-#define DUK_DEC_ABC(x)              (((x) >> 8) & 0xffffffUL)
+#define DUK_DEC_OP(x)  ((x) &0xffUL)
+#define DUK_DEC_A(x)   (((x) >> 8) & 0xffUL)
+#define DUK_DEC_B(x)   (((x) >> 16) & 0xffUL)
+#define DUK_DEC_C(x)   (((x) >> 24) & 0xffUL)
+#define DUK_DEC_BC(x)  (((x) >> 16) & 0xffffUL)
+#define DUK_DEC_ABC(x) (((x) >> 8) & 0xffffffUL)
 
-#define DUK_ENC_OP(op)              ((duk_instr_t) (op))
-#define DUK_ENC_OP_ABC(op,abc)      ((duk_instr_t) ( \
-                                        (((duk_instr_t) (abc)) << 8) | \
-                                        ((duk_instr_t) (op)) \
-                                    ))
-#define DUK_ENC_OP_A_BC(op,a,bc)    ((duk_instr_t) ( \
-                                        (((duk_instr_t) (bc)) << 16) | \
-                                        (((duk_instr_t) (a)) << 8) | \
-                                        ((duk_instr_t) (op)) \
-                                    ))
-#define DUK_ENC_OP_A_B_C(op,a,b,c)  ((duk_instr_t) ( \
-                                        (((duk_instr_t) (c)) << 24) | \
-                                        (((duk_instr_t) (b)) << 16) | \
-                                        (((duk_instr_t) (a)) << 8) | \
-                                        ((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)
-#define DUK_ENC_OP_BC(op,bc)        DUK_ENC_OP_A_BC((op),0,(bc))
+#define DUK_ENC_OP(op)          ((duk_instr_t) (op))
+#define DUK_ENC_OP_ABC(op, abc) ((duk_instr_t) ((((duk_instr_t) (abc)) << 8) | ((duk_instr_t) (op))))
+#define DUK_ENC_OP_A_BC(op, a, bc) \
+	((duk_instr_t) ((((duk_instr_t) (bc)) << 16) | (((duk_instr_t) (a)) << 8) | ((duk_instr_t) (op))))
+#define DUK_ENC_OP_A_B_C(op, a, b, c) \
+	((duk_instr_t) ((((duk_instr_t) (c)) << 24) | (((duk_instr_t) (b)) << 16) | (((duk_instr_t) (a)) << 8) | \
+	                ((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)
+#define DUK_ENC_OP_BC(op, bc)    DUK_ENC_OP_A_BC((op), 0, (bc))
 
 /* Get opcode base value with B/C reg/const flags cleared. */
-#define DUK_BC_NOREGCONST_OP(op)    ((op) & 0xfc)
+#define DUK_BC_NOREGCONST_OP(op) ((op) &0xfc)
 
 /* 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               0xffL
-#define DUK_BC_A_MIN                0
-#define DUK_BC_A_MAX                0xffL
-#define DUK_BC_B_MIN                0
-#define DUK_BC_B_MAX                0xffL
-#define DUK_BC_C_MIN                0
-#define DUK_BC_C_MAX                0xffL
-#define DUK_BC_BC_MIN               0
-#define DUK_BC_BC_MAX               0xffffL
-#define DUK_BC_ABC_MIN              0
-#define DUK_BC_ABC_MAX              0xffffffL
+#define DUK_BC_OP_MIN  0
+#define DUK_BC_OP_MAX  0xffL
+#define DUK_BC_A_MIN   0
+#define DUK_BC_A_MAX   0xffL
+#define DUK_BC_B_MIN   0
+#define DUK_BC_B_MAX   0xffL
+#define DUK_BC_C_MIN   0
+#define DUK_BC_C_MAX   0xffL
+#define DUK_BC_BC_MIN  0
+#define DUK_BC_BC_MAX  0xffffL
+#define DUK_BC_ABC_MIN 0
+#define DUK_BC_ABC_MAX 0xffffffL
 
 /* Masks for B/C reg/const indicator in opcode field. */
-#define DUK_BC_REGCONST_B           (0x01UL)
-#define DUK_BC_REGCONST_C           (0x02UL)
+#define DUK_BC_REGCONST_B (0x01UL)
+#define DUK_BC_REGCONST_C (0x02UL)
 
 /* Misc. masks for opcode field. */
-#define DUK_BC_INCDECP_FLAG_DEC     (0x04UL)
-#define DUK_BC_INCDECP_FLAG_POST    (0x08UL)
+#define DUK_BC_INCDECP_FLAG_DEC  (0x04UL)
+#define DUK_BC_INCDECP_FLAG_POST (0x08UL)
 
 /* Opcodes. */
-#define DUK_OP_LDREG                0
-#define DUK_OP_STREG                1
-#define DUK_OP_JUMP                 2
-#define DUK_OP_LDCONST              3
-#define DUK_OP_LDINT                4
-#define DUK_OP_LDINTX               5
-#define DUK_OP_LDTHIS               6
-#define DUK_OP_LDUNDEF              7
-#define DUK_OP_LDNULL               8
-#define DUK_OP_LDTRUE               9
-#define DUK_OP_LDFALSE              10
-#define DUK_OP_GETVAR               11
-#define DUK_OP_BNOT                 12
-#define DUK_OP_LNOT                 13
-#define DUK_OP_UNM                  14
-#define DUK_OP_UNP                  15
-#define DUK_OP_EQ                   16
-#define DUK_OP_EQ_RR                16
-#define DUK_OP_EQ_CR                17
-#define DUK_OP_EQ_RC                18
-#define DUK_OP_EQ_CC                19
-#define DUK_OP_NEQ                  20
-#define DUK_OP_NEQ_RR               20
-#define DUK_OP_NEQ_CR               21
-#define DUK_OP_NEQ_RC               22
-#define DUK_OP_NEQ_CC               23
-#define DUK_OP_SEQ                  24
-#define DUK_OP_SEQ_RR               24
-#define DUK_OP_SEQ_CR               25
-#define DUK_OP_SEQ_RC               26
-#define DUK_OP_SEQ_CC               27
-#define DUK_OP_SNEQ                 28
-#define DUK_OP_SNEQ_RR              28
-#define DUK_OP_SNEQ_CR              29
-#define DUK_OP_SNEQ_RC              30
-#define DUK_OP_SNEQ_CC              31
-#define DUK_OP_GT                   32
-#define DUK_OP_GT_RR                32
-#define DUK_OP_GT_CR                33
-#define DUK_OP_GT_RC                34
-#define DUK_OP_GT_CC                35
-#define DUK_OP_GE                   36
-#define DUK_OP_GE_RR                36
-#define DUK_OP_GE_CR                37
-#define DUK_OP_GE_RC                38
-#define DUK_OP_GE_CC                39
-#define DUK_OP_LT                   40
-#define DUK_OP_LT_RR                40
-#define DUK_OP_LT_CR                41
-#define DUK_OP_LT_RC                42
-#define DUK_OP_LT_CC                43
-#define DUK_OP_LE                   44
-#define DUK_OP_LE_RR                44
-#define DUK_OP_LE_CR                45
-#define DUK_OP_LE_RC                46
-#define DUK_OP_LE_CC                47
-#define DUK_OP_IFTRUE               48
-#define DUK_OP_IFTRUE_R             48
-#define DUK_OP_IFTRUE_C             49
-#define DUK_OP_IFFALSE              50
-#define DUK_OP_IFFALSE_R            50
-#define DUK_OP_IFFALSE_C            51
-#define DUK_OP_ADD                  52
-#define DUK_OP_ADD_RR               52
-#define DUK_OP_ADD_CR               53
-#define DUK_OP_ADD_RC               54
-#define DUK_OP_ADD_CC               55
-#define DUK_OP_SUB                  56
-#define DUK_OP_SUB_RR               56
-#define DUK_OP_SUB_CR               57
-#define DUK_OP_SUB_RC               58
-#define DUK_OP_SUB_CC               59
-#define DUK_OP_MUL                  60
-#define DUK_OP_MUL_RR               60
-#define DUK_OP_MUL_CR               61
-#define DUK_OP_MUL_RC               62
-#define DUK_OP_MUL_CC               63
-#define DUK_OP_DIV                  64
-#define DUK_OP_DIV_RR               64
-#define DUK_OP_DIV_CR               65
-#define DUK_OP_DIV_RC               66
-#define DUK_OP_DIV_CC               67
-#define DUK_OP_MOD                  68
-#define DUK_OP_MOD_RR               68
-#define DUK_OP_MOD_CR               69
-#define DUK_OP_MOD_RC               70
-#define DUK_OP_MOD_CC               71
-#define DUK_OP_EXP                  72
-#define DUK_OP_EXP_RR               72
-#define DUK_OP_EXP_CR               73
-#define DUK_OP_EXP_RC               74
-#define DUK_OP_EXP_CC               75
-#define DUK_OP_BAND                 76
-#define DUK_OP_BAND_RR              76
-#define DUK_OP_BAND_CR              77
-#define DUK_OP_BAND_RC              78
-#define DUK_OP_BAND_CC              79
-#define DUK_OP_BOR                  80
-#define DUK_OP_BOR_RR               80
-#define DUK_OP_BOR_CR               81
-#define DUK_OP_BOR_RC               82
-#define DUK_OP_BOR_CC               83
-#define DUK_OP_BXOR                 84
-#define DUK_OP_BXOR_RR              84
-#define DUK_OP_BXOR_CR              85
-#define DUK_OP_BXOR_RC              86
-#define DUK_OP_BXOR_CC              87
-#define DUK_OP_BASL                 88
-#define DUK_OP_BASL_RR              88
-#define DUK_OP_BASL_CR              89
-#define DUK_OP_BASL_RC              90
-#define DUK_OP_BASL_CC              91
-#define DUK_OP_BLSR                 92
-#define DUK_OP_BLSR_RR              92
-#define DUK_OP_BLSR_CR              93
-#define DUK_OP_BLSR_RC              94
-#define DUK_OP_BLSR_CC              95
-#define DUK_OP_BASR                 96
-#define DUK_OP_BASR_RR              96
-#define DUK_OP_BASR_CR              97
-#define DUK_OP_BASR_RC              98
-#define DUK_OP_BASR_CC              99
-#define DUK_OP_INSTOF               100
-#define DUK_OP_INSTOF_RR            100
-#define DUK_OP_INSTOF_CR            101
-#define DUK_OP_INSTOF_RC            102
-#define DUK_OP_INSTOF_CC            103
-#define DUK_OP_IN                   104
-#define DUK_OP_IN_RR                104
-#define DUK_OP_IN_CR                105
-#define DUK_OP_IN_RC                106
-#define DUK_OP_IN_CC                107
-#define DUK_OP_GETPROP              108
-#define DUK_OP_GETPROP_RR           108
-#define DUK_OP_GETPROP_CR           109
-#define DUK_OP_GETPROP_RC           110
-#define DUK_OP_GETPROP_CC           111
-#define DUK_OP_PUTPROP              112
-#define DUK_OP_PUTPROP_RR           112
-#define DUK_OP_PUTPROP_CR           113
-#define DUK_OP_PUTPROP_RC           114
-#define DUK_OP_PUTPROP_CC           115
-#define DUK_OP_DELPROP              116
-#define DUK_OP_DELPROP_RR           116
-#define DUK_OP_DELPROP_CR_UNUSED    117  /* unused now */
-#define DUK_OP_DELPROP_RC           118
-#define DUK_OP_DELPROP_CC_UNUSED    119  /* unused now */
-#define DUK_OP_PREINCR              120  /* pre/post opcode values have constraints, */
-#define DUK_OP_PREDECR              121  /* see duk_js_executor.c and duk_js_compiler.c. */
-#define DUK_OP_POSTINCR             122
-#define DUK_OP_POSTDECR             123
-#define DUK_OP_PREINCV              124
-#define DUK_OP_PREDECV              125
-#define DUK_OP_POSTINCV             126
-#define DUK_OP_POSTDECV             127
-#define DUK_OP_PREINCP              128  /* pre/post inc/dec prop opcodes have constraints */
-#define DUK_OP_PREINCP_RR           128
-#define DUK_OP_PREINCP_CR           129
-#define DUK_OP_PREINCP_RC           130
-#define DUK_OP_PREINCP_CC           131
-#define DUK_OP_PREDECP              132
-#define DUK_OP_PREDECP_RR           132
-#define DUK_OP_PREDECP_CR           133
-#define DUK_OP_PREDECP_RC           134
-#define DUK_OP_PREDECP_CC           135
-#define DUK_OP_POSTINCP             136
-#define DUK_OP_POSTINCP_RR          136
-#define DUK_OP_POSTINCP_CR          137
-#define DUK_OP_POSTINCP_RC          138
-#define DUK_OP_POSTINCP_CC          139
-#define DUK_OP_POSTDECP             140
-#define DUK_OP_POSTDECP_RR          140
-#define DUK_OP_POSTDECP_CR          141
-#define DUK_OP_POSTDECP_RC          142
-#define DUK_OP_POSTDECP_CC          143
-#define DUK_OP_DECLVAR              144
-#define DUK_OP_DECLVAR_RR           144
-#define DUK_OP_DECLVAR_CR           145
-#define DUK_OP_DECLVAR_RC           146
-#define DUK_OP_DECLVAR_CC           147
-#define DUK_OP_REGEXP               148
-#define DUK_OP_REGEXP_RR            148
-#define DUK_OP_REGEXP_CR            149
-#define DUK_OP_REGEXP_RC            150
-#define DUK_OP_REGEXP_CC            151
-#define DUK_OP_CLOSURE              152
-#define DUK_OP_TYPEOF               153
-#define DUK_OP_TYPEOFID             154
-#define DUK_OP_PUTVAR               155
-#define DUK_OP_DELVAR               156
-#define DUK_OP_RETREG               157
-#define DUK_OP_RETUNDEF             158
-#define DUK_OP_RETCONST             159
-#define DUK_OP_RETCONSTN            160  /* return const without incref (e.g. number) */
-#define DUK_OP_LABEL                161
-#define DUK_OP_ENDLABEL             162
-#define DUK_OP_BREAK                163
-#define DUK_OP_CONTINUE             164
-#define DUK_OP_TRYCATCH             165
-#define DUK_OP_ENDTRY               166
-#define DUK_OP_ENDCATCH             167
-#define DUK_OP_ENDFIN               168
-#define DUK_OP_THROW                169
-#define DUK_OP_INVLHS               170
-#define DUK_OP_CSREG                171
-#define DUK_OP_CSVAR                172
-#define DUK_OP_CSVAR_RR             172
-#define DUK_OP_CSVAR_CR             173
-#define DUK_OP_CSVAR_RC             174
-#define DUK_OP_CSVAR_CC             175
-#define DUK_OP_CALL0                176  /* DUK_OP_CALL0 & 0x0F must be zero. */
-#define DUK_OP_CALL1                177
-#define DUK_OP_CALL2                178
-#define DUK_OP_CALL3                179
-#define DUK_OP_CALL4                180
-#define DUK_OP_CALL5                181
-#define DUK_OP_CALL6                182
-#define DUK_OP_CALL7                183
-#define DUK_OP_CALL8                184
-#define DUK_OP_CALL9                185
-#define DUK_OP_CALL10               186
-#define DUK_OP_CALL11               187
-#define DUK_OP_CALL12               188
-#define DUK_OP_CALL13               189
-#define DUK_OP_CALL14               190
-#define DUK_OP_CALL15               191
-#define DUK_OP_NEWOBJ               192
-#define DUK_OP_NEWARR               193
-#define DUK_OP_MPUTOBJ              194
-#define DUK_OP_MPUTOBJI             195
-#define DUK_OP_INITSET              196
-#define DUK_OP_INITGET              197
-#define DUK_OP_MPUTARR              198
-#define DUK_OP_MPUTARRI             199
-#define DUK_OP_SETALEN              200
-#define DUK_OP_INITENUM             201
-#define DUK_OP_NEXTENUM             202
-#define DUK_OP_NEWTARGET            203
-#define DUK_OP_DEBUGGER             204
-#define DUK_OP_NOP                  205
-#define DUK_OP_INVALID              206
-#define DUK_OP_UNUSED207            207
-#define DUK_OP_GETPROPC             208
-#define DUK_OP_GETPROPC_RR          208
-#define DUK_OP_GETPROPC_CR          209
-#define DUK_OP_GETPROPC_RC          210
-#define DUK_OP_GETPROPC_CC          211
-#define DUK_OP_UNUSED212            212
-#define DUK_OP_UNUSED213            213
-#define DUK_OP_UNUSED214            214
-#define DUK_OP_UNUSED215            215
-#define DUK_OP_UNUSED216            216
-#define DUK_OP_UNUSED217            217
-#define DUK_OP_UNUSED218            218
-#define DUK_OP_UNUSED219            219
-#define DUK_OP_UNUSED220            220
-#define DUK_OP_UNUSED221            221
-#define DUK_OP_UNUSED222            222
-#define DUK_OP_UNUSED223            223
-#define DUK_OP_UNUSED224            224
-#define DUK_OP_UNUSED225            225
-#define DUK_OP_UNUSED226            226
-#define DUK_OP_UNUSED227            227
-#define DUK_OP_UNUSED228            228
-#define DUK_OP_UNUSED229            229
-#define DUK_OP_UNUSED230            230
-#define DUK_OP_UNUSED231            231
-#define DUK_OP_UNUSED232            232
-#define DUK_OP_UNUSED233            233
-#define DUK_OP_UNUSED234            234
-#define DUK_OP_UNUSED235            235
-#define DUK_OP_UNUSED236            236
-#define DUK_OP_UNUSED237            237
-#define DUK_OP_UNUSED238            238
-#define DUK_OP_UNUSED239            239
-#define DUK_OP_UNUSED240            240
-#define DUK_OP_UNUSED241            241
-#define DUK_OP_UNUSED242            242
-#define DUK_OP_UNUSED243            243
-#define DUK_OP_UNUSED244            244
-#define DUK_OP_UNUSED245            245
-#define DUK_OP_UNUSED246            246
-#define DUK_OP_UNUSED247            247
-#define DUK_OP_UNUSED248            248
-#define DUK_OP_UNUSED249            249
-#define DUK_OP_UNUSED250            250
-#define DUK_OP_UNUSED251            251
-#define DUK_OP_UNUSED252            252
-#define DUK_OP_UNUSED253            253
-#define DUK_OP_UNUSED254            254
-#define DUK_OP_UNUSED255            255
-#define DUK_OP_NONE                 256  /* dummy value used as marker (doesn't fit in 8-bit field) */
+#define DUK_OP_LDREG             0
+#define DUK_OP_STREG             1
+#define DUK_OP_JUMP              2
+#define DUK_OP_LDCONST           3
+#define DUK_OP_LDINT             4
+#define DUK_OP_LDINTX            5
+#define DUK_OP_LDTHIS            6
+#define DUK_OP_LDUNDEF           7
+#define DUK_OP_LDNULL            8
+#define DUK_OP_LDTRUE            9
+#define DUK_OP_LDFALSE           10
+#define DUK_OP_GETVAR            11
+#define DUK_OP_BNOT              12
+#define DUK_OP_LNOT              13
+#define DUK_OP_UNM               14
+#define DUK_OP_UNP               15
+#define DUK_OP_EQ                16
+#define DUK_OP_EQ_RR             16
+#define DUK_OP_EQ_CR             17
+#define DUK_OP_EQ_RC             18
+#define DUK_OP_EQ_CC             19
+#define DUK_OP_NEQ               20
+#define DUK_OP_NEQ_RR            20
+#define DUK_OP_NEQ_CR            21
+#define DUK_OP_NEQ_RC            22
+#define DUK_OP_NEQ_CC            23
+#define DUK_OP_SEQ               24
+#define DUK_OP_SEQ_RR            24
+#define DUK_OP_SEQ_CR            25
+#define DUK_OP_SEQ_RC            26
+#define DUK_OP_SEQ_CC            27
+#define DUK_OP_SNEQ              28
+#define DUK_OP_SNEQ_RR           28
+#define DUK_OP_SNEQ_CR           29
+#define DUK_OP_SNEQ_RC           30
+#define DUK_OP_SNEQ_CC           31
+#define DUK_OP_GT                32
+#define DUK_OP_GT_RR             32
+#define DUK_OP_GT_CR             33
+#define DUK_OP_GT_RC             34
+#define DUK_OP_GT_CC             35
+#define DUK_OP_GE                36
+#define DUK_OP_GE_RR             36
+#define DUK_OP_GE_CR             37
+#define DUK_OP_GE_RC             38
+#define DUK_OP_GE_CC             39
+#define DUK_OP_LT                40
+#define DUK_OP_LT_RR             40
+#define DUK_OP_LT_CR             41
+#define DUK_OP_LT_RC             42
+#define DUK_OP_LT_CC             43
+#define DUK_OP_LE                44
+#define DUK_OP_LE_RR             44
+#define DUK_OP_LE_CR             45
+#define DUK_OP_LE_RC             46
+#define DUK_OP_LE_CC             47
+#define DUK_OP_IFTRUE            48
+#define DUK_OP_IFTRUE_R          48
+#define DUK_OP_IFTRUE_C          49
+#define DUK_OP_IFFALSE           50
+#define DUK_OP_IFFALSE_R         50
+#define DUK_OP_IFFALSE_C         51
+#define DUK_OP_ADD               52
+#define DUK_OP_ADD_RR            52
+#define DUK_OP_ADD_CR            53
+#define DUK_OP_ADD_RC            54
+#define DUK_OP_ADD_CC            55
+#define DUK_OP_SUB               56
+#define DUK_OP_SUB_RR            56
+#define DUK_OP_SUB_CR            57
+#define DUK_OP_SUB_RC            58
+#define DUK_OP_SUB_CC            59
+#define DUK_OP_MUL               60
+#define DUK_OP_MUL_RR            60
+#define DUK_OP_MUL_CR            61
+#define DUK_OP_MUL_RC            62
+#define DUK_OP_MUL_CC            63
+#define DUK_OP_DIV               64
+#define DUK_OP_DIV_RR            64
+#define DUK_OP_DIV_CR            65
+#define DUK_OP_DIV_RC            66
+#define DUK_OP_DIV_CC            67
+#define DUK_OP_MOD               68
+#define DUK_OP_MOD_RR            68
+#define DUK_OP_MOD_CR            69
+#define DUK_OP_MOD_RC            70
+#define DUK_OP_MOD_CC            71
+#define DUK_OP_EXP               72
+#define DUK_OP_EXP_RR            72
+#define DUK_OP_EXP_CR            73
+#define DUK_OP_EXP_RC            74
+#define DUK_OP_EXP_CC            75
+#define DUK_OP_BAND              76
+#define DUK_OP_BAND_RR           76
+#define DUK_OP_BAND_CR           77
+#define DUK_OP_BAND_RC           78
+#define DUK_OP_BAND_CC           79
+#define DUK_OP_BOR               80
+#define DUK_OP_BOR_RR            80
+#define DUK_OP_BOR_CR            81
+#define DUK_OP_BOR_RC            82
+#define DUK_OP_BOR_CC            83
+#define DUK_OP_BXOR              84
+#define DUK_OP_BXOR_RR           84
+#define DUK_OP_BXOR_CR           85
+#define DUK_OP_BXOR_RC           86
+#define DUK_OP_BXOR_CC           87
+#define DUK_OP_BASL              88
+#define DUK_OP_BASL_RR           88
+#define DUK_OP_BASL_CR           89
+#define DUK_OP_BASL_RC           90
+#define DUK_OP_BASL_CC           91
+#define DUK_OP_BLSR              92
+#define DUK_OP_BLSR_RR           92
+#define DUK_OP_BLSR_CR           93
+#define DUK_OP_BLSR_RC           94
+#define DUK_OP_BLSR_CC           95
+#define DUK_OP_BASR              96
+#define DUK_OP_BASR_RR           96
+#define DUK_OP_BASR_CR           97
+#define DUK_OP_BASR_RC           98
+#define DUK_OP_BASR_CC           99
+#define DUK_OP_INSTOF            100
+#define DUK_OP_INSTOF_RR         100
+#define DUK_OP_INSTOF_CR         101
+#define DUK_OP_INSTOF_RC         102
+#define DUK_OP_INSTOF_CC         103
+#define DUK_OP_IN                104
+#define DUK_OP_IN_RR             104
+#define DUK_OP_IN_CR             105
+#define DUK_OP_IN_RC             106
+#define DUK_OP_IN_CC             107
+#define DUK_OP_GETPROP           108
+#define DUK_OP_GETPROP_RR        108
+#define DUK_OP_GETPROP_CR        109
+#define DUK_OP_GETPROP_RC        110
+#define DUK_OP_GETPROP_CC        111
+#define DUK_OP_PUTPROP           112
+#define DUK_OP_PUTPROP_RR        112
+#define DUK_OP_PUTPROP_CR        113
+#define DUK_OP_PUTPROP_RC        114
+#define DUK_OP_PUTPROP_CC        115
+#define DUK_OP_DELPROP           116
+#define DUK_OP_DELPROP_RR        116
+#define DUK_OP_DELPROP_CR_UNUSED 117 /* unused now */
+#define DUK_OP_DELPROP_RC        118
+#define DUK_OP_DELPROP_CC_UNUSED 119 /* unused now */
+#define DUK_OP_PREINCR           120 /* pre/post opcode values have constraints, */
+#define DUK_OP_PREDECR           121 /* see duk_js_executor.c and duk_js_compiler.c. */
+#define DUK_OP_POSTINCR          122
+#define DUK_OP_POSTDECR          123
+#define DUK_OP_PREINCV           124
+#define DUK_OP_PREDECV           125
+#define DUK_OP_POSTINCV          126
+#define DUK_OP_POSTDECV          127
+#define DUK_OP_PREINCP           128 /* pre/post inc/dec prop opcodes have constraints */
+#define DUK_OP_PREINCP_RR        128
+#define DUK_OP_PREINCP_CR        129
+#define DUK_OP_PREINCP_RC        130
+#define DUK_OP_PREINCP_CC        131
+#define DUK_OP_PREDECP           132
+#define DUK_OP_PREDECP_RR        132
+#define DUK_OP_PREDECP_CR        133
+#define DUK_OP_PREDECP_RC        134
+#define DUK_OP_PREDECP_CC        135
+#define DUK_OP_POSTINCP          136
+#define DUK_OP_POSTINCP_RR       136
+#define DUK_OP_POSTINCP_CR       137
+#define DUK_OP_POSTINCP_RC       138
+#define DUK_OP_POSTINCP_CC       139
+#define DUK_OP_POSTDECP          140
+#define DUK_OP_POSTDECP_RR       140
+#define DUK_OP_POSTDECP_CR       141
+#define DUK_OP_POSTDECP_RC       142
+#define DUK_OP_POSTDECP_CC       143
+#define DUK_OP_DECLVAR           144
+#define DUK_OP_DECLVAR_RR        144
+#define DUK_OP_DECLVAR_CR        145
+#define DUK_OP_DECLVAR_RC        146
+#define DUK_OP_DECLVAR_CC        147
+#define DUK_OP_REGEXP            148
+#define DUK_OP_REGEXP_RR         148
+#define DUK_OP_REGEXP_CR         149
+#define DUK_OP_REGEXP_RC         150
+#define DUK_OP_REGEXP_CC         151
+#define DUK_OP_CLOSURE           152
+#define DUK_OP_TYPEOF            153
+#define DUK_OP_TYPEOFID          154
+#define DUK_OP_PUTVAR            155
+#define DUK_OP_DELVAR            156
+#define DUK_OP_RETREG            157
+#define DUK_OP_RETUNDEF          158
+#define DUK_OP_RETCONST          159
+#define DUK_OP_RETCONSTN         160 /* return const without incref (e.g. number) */
+#define DUK_OP_LABEL             161
+#define DUK_OP_ENDLABEL          162
+#define DUK_OP_BREAK             163
+#define DUK_OP_CONTINUE          164
+#define DUK_OP_TRYCATCH          165
+#define DUK_OP_ENDTRY            166
+#define DUK_OP_ENDCATCH          167
+#define DUK_OP_ENDFIN            168
+#define DUK_OP_THROW             169
+#define DUK_OP_INVLHS            170
+#define DUK_OP_CSREG             171
+#define DUK_OP_CSVAR             172
+#define DUK_OP_CSVAR_RR          172
+#define DUK_OP_CSVAR_CR          173
+#define DUK_OP_CSVAR_RC          174
+#define DUK_OP_CSVAR_CC          175
+#define DUK_OP_CALL0             176 /* DUK_OP_CALL0 & 0x0F must be zero. */
+#define DUK_OP_CALL1             177
+#define DUK_OP_CALL2             178
+#define DUK_OP_CALL3             179
+#define DUK_OP_CALL4             180
+#define DUK_OP_CALL5             181
+#define DUK_OP_CALL6             182
+#define DUK_OP_CALL7             183
+#define DUK_OP_CALL8             184
+#define DUK_OP_CALL9             185
+#define DUK_OP_CALL10            186
+#define DUK_OP_CALL11            187
+#define DUK_OP_CALL12            188
+#define DUK_OP_CALL13            189
+#define DUK_OP_CALL14            190
+#define DUK_OP_CALL15            191
+#define DUK_OP_NEWOBJ            192
+#define DUK_OP_NEWARR            193
+#define DUK_OP_MPUTOBJ           194
+#define DUK_OP_MPUTOBJI          195
+#define DUK_OP_INITSET           196
+#define DUK_OP_INITGET           197
+#define DUK_OP_MPUTARR           198
+#define DUK_OP_MPUTARRI          199
+#define DUK_OP_SETALEN           200
+#define DUK_OP_INITENUM          201
+#define DUK_OP_NEXTENUM          202
+#define DUK_OP_NEWTARGET         203
+#define DUK_OP_DEBUGGER          204
+#define DUK_OP_NOP               205
+#define DUK_OP_INVALID           206
+#define DUK_OP_UNUSED207         207
+#define DUK_OP_GETPROPC          208
+#define DUK_OP_GETPROPC_RR       208
+#define DUK_OP_GETPROPC_CR       209
+#define DUK_OP_GETPROPC_RC       210
+#define DUK_OP_GETPROPC_CC       211
+#define DUK_OP_UNUSED212         212
+#define DUK_OP_UNUSED213         213
+#define DUK_OP_UNUSED214         214
+#define DUK_OP_UNUSED215         215
+#define DUK_OP_UNUSED216         216
+#define DUK_OP_UNUSED217         217
+#define DUK_OP_UNUSED218         218
+#define DUK_OP_UNUSED219         219
+#define DUK_OP_UNUSED220         220
+#define DUK_OP_UNUSED221         221
+#define DUK_OP_UNUSED222         222
+#define DUK_OP_UNUSED223         223
+#define DUK_OP_UNUSED224         224
+#define DUK_OP_UNUSED225         225
+#define DUK_OP_UNUSED226         226
+#define DUK_OP_UNUSED227         227
+#define DUK_OP_UNUSED228         228
+#define DUK_OP_UNUSED229         229
+#define DUK_OP_UNUSED230         230
+#define DUK_OP_UNUSED231         231
+#define DUK_OP_UNUSED232         232
+#define DUK_OP_UNUSED233         233
+#define DUK_OP_UNUSED234         234
+#define DUK_OP_UNUSED235         235
+#define DUK_OP_UNUSED236         236
+#define DUK_OP_UNUSED237         237
+#define DUK_OP_UNUSED238         238
+#define DUK_OP_UNUSED239         239
+#define DUK_OP_UNUSED240         240
+#define DUK_OP_UNUSED241         241
+#define DUK_OP_UNUSED242         242
+#define DUK_OP_UNUSED243         243
+#define DUK_OP_UNUSED244         244
+#define DUK_OP_UNUSED245         245
+#define DUK_OP_UNUSED246         246
+#define DUK_OP_UNUSED247         247
+#define DUK_OP_UNUSED248         248
+#define DUK_OP_UNUSED249         249
+#define DUK_OP_UNUSED250         250
+#define DUK_OP_UNUSED251         251
+#define DUK_OP_UNUSED252         252
+#define DUK_OP_UNUSED253         253
+#define DUK_OP_UNUSED254         254
+#define DUK_OP_UNUSED255         255
+#define DUK_OP_NONE              256 /* dummy value used as marker (doesn't fit in 8-bit field) */
 
 /* XXX: Allocate flags from opcode field?  Would take 16 opcode slots
  * but avoids shuffling in more cases.  Maybe not worth it.
  */
 /* DUK_OP_TRYCATCH flags in A. */
-#define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH     (1U << 0)
-#define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY   (1U << 1)
-#define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING  (1U << 2)
-#define DUK_BC_TRYCATCH_FLAG_WITH_BINDING   (1U << 3)
+#define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH    (1U << 0)
+#define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY  (1U << 1)
+#define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING (1U << 2)
+#define DUK_BC_TRYCATCH_FLAG_WITH_BINDING  (1U << 3)
 
 /* DUK_OP_DECLVAR flags in A; bottom bits are reserved for propdesc flags
  * (DUK_PROPDESC_FLAG_XXX).
  */
-#define DUK_BC_DECLVAR_FLAG_FUNC_DECL       (1U << 4)  /* function declaration */
+#define DUK_BC_DECLVAR_FLAG_FUNC_DECL (1U << 4) /* function declaration */
 
 /* DUK_OP_CALLn flags, part of opcode field.  Three lowest bits must match
  * DUK_CALL_FLAG_xxx directly.
  */
-#define DUK_BC_CALL_FLAG_TAILCALL           (1U << 0)
-#define DUK_BC_CALL_FLAG_CONSTRUCT          (1U << 1)
-#define DUK_BC_CALL_FLAG_CALLED_AS_EVAL     (1U << 2)
-#define DUK_BC_CALL_FLAG_INDIRECT           (1U << 3)
+#define DUK_BC_CALL_FLAG_TAILCALL       (1U << 0)
+#define DUK_BC_CALL_FLAG_CONSTRUCT      (1U << 1)
+#define DUK_BC_CALL_FLAG_CALLED_AS_EVAL (1U << 2)
+#define DUK_BC_CALL_FLAG_INDIRECT       (1U << 3)
 
 /* Misc constants and helper macros. */
-#define DUK_BC_LDINT_BIAS           (1L << 15)
-#define DUK_BC_LDINTX_SHIFT         16
-#define DUK_BC_JUMP_BIAS            (1L << 23)
+#define DUK_BC_LDINT_BIAS   (1L << 15)
+#define DUK_BC_LDINTX_SHIFT 16
+#define DUK_BC_JUMP_BIAS    (1L << 23)
 
-#endif  /* DUK_JS_BYTECODE_H_INCLUDED */
+#endif /* DUK_JS_BYTECODE_H_INCLUDED */
 /* #include duk_lexer.h */
 #line 1 "duk_lexer.h"
 /*
@@ -3745,156 +3840,156 @@
  *  in a continuous range and in a particular order.  See genstrings.py.
  */
 
-#define DUK_LEXER_INITCTX(ctx)        duk_lexer_initctx((ctx))
+#define DUK_LEXER_INITCTX(ctx) duk_lexer_initctx((ctx))
 
-#define DUK_LEXER_SETPOINT(ctx,pt)    duk_lexer_setpoint((ctx), (pt))
+#define DUK_LEXER_SETPOINT(ctx, pt) duk_lexer_setpoint((ctx), (pt))
 
-#define DUK_LEXER_GETPOINT(ctx,pt)    duk_lexer_getpoint((ctx), (pt))
+#define DUK_LEXER_GETPOINT(ctx, pt) duk_lexer_getpoint((ctx), (pt))
 
 /* Currently 6 characters of lookup are actually needed (duk_lexer.c). */
-#define DUK_LEXER_WINDOW_SIZE                     6
+#define DUK_LEXER_WINDOW_SIZE 6
 #if defined(DUK_USE_LEXER_SLIDING_WINDOW)
-#define DUK_LEXER_BUFFER_SIZE                     64
+#define DUK_LEXER_BUFFER_SIZE 64
 #endif
 
-#define DUK_TOK_MINVAL                            0
+#define DUK_TOK_MINVAL 0
 
 /* returned after EOF (infinite amount) */
-#define DUK_TOK_EOF                               0
+#define DUK_TOK_EOF 0
 
 /* identifier names (E5 Section 7.6) */
-#define DUK_TOK_IDENTIFIER                        1
+#define DUK_TOK_IDENTIFIER 1
 
 /* reserved words: keywords */
-#define DUK_TOK_START_RESERVED                    2
-#define DUK_TOK_BREAK                             2
-#define DUK_TOK_CASE                              3
-#define DUK_TOK_CATCH                             4
-#define DUK_TOK_CONTINUE                          5
-#define DUK_TOK_DEBUGGER                          6
-#define DUK_TOK_DEFAULT                           7
-#define DUK_TOK_DELETE                            8
-#define DUK_TOK_DO                                9
-#define DUK_TOK_ELSE                              10
-#define DUK_TOK_FINALLY                           11
-#define DUK_TOK_FOR                               12
-#define DUK_TOK_FUNCTION                          13
-#define DUK_TOK_IF                                14
-#define DUK_TOK_IN                                15
-#define DUK_TOK_INSTANCEOF                        16
-#define DUK_TOK_NEW                               17
-#define DUK_TOK_RETURN                            18
-#define DUK_TOK_SWITCH                            19
-#define DUK_TOK_THIS                              20
-#define DUK_TOK_THROW                             21
-#define DUK_TOK_TRY                               22
-#define DUK_TOK_TYPEOF                            23
-#define DUK_TOK_VAR                               24
-#define DUK_TOK_CONST                             25
-#define DUK_TOK_VOID                              26
-#define DUK_TOK_WHILE                             27
-#define DUK_TOK_WITH                              28
+#define DUK_TOK_START_RESERVED 2
+#define DUK_TOK_BREAK          2
+#define DUK_TOK_CASE           3
+#define DUK_TOK_CATCH          4
+#define DUK_TOK_CONTINUE       5
+#define DUK_TOK_DEBUGGER       6
+#define DUK_TOK_DEFAULT        7
+#define DUK_TOK_DELETE         8
+#define DUK_TOK_DO             9
+#define DUK_TOK_ELSE           10
+#define DUK_TOK_FINALLY        11
+#define DUK_TOK_FOR            12
+#define DUK_TOK_FUNCTION       13
+#define DUK_TOK_IF             14
+#define DUK_TOK_IN             15
+#define DUK_TOK_INSTANCEOF     16
+#define DUK_TOK_NEW            17
+#define DUK_TOK_RETURN         18
+#define DUK_TOK_SWITCH         19
+#define DUK_TOK_THIS           20
+#define DUK_TOK_THROW          21
+#define DUK_TOK_TRY            22
+#define DUK_TOK_TYPEOF         23
+#define DUK_TOK_VAR            24
+#define DUK_TOK_CONST          25
+#define DUK_TOK_VOID           26
+#define DUK_TOK_WHILE          27
+#define DUK_TOK_WITH           28
 
 /* reserved words: future reserved words */
-#define DUK_TOK_CLASS                             29
-#define DUK_TOK_ENUM                              30
-#define DUK_TOK_EXPORT                            31
-#define DUK_TOK_EXTENDS                           32
-#define DUK_TOK_IMPORT                            33
-#define DUK_TOK_SUPER                             34
+#define DUK_TOK_CLASS   29
+#define DUK_TOK_ENUM    30
+#define DUK_TOK_EXPORT  31
+#define DUK_TOK_EXTENDS 32
+#define DUK_TOK_IMPORT  33
+#define DUK_TOK_SUPER   34
 
 /* "null", "true", and "false" are always reserved words.
  * Note that "get" and "set" are not!
  */
-#define DUK_TOK_NULL                              35
-#define DUK_TOK_TRUE                              36
-#define DUK_TOK_FALSE                             37
+#define DUK_TOK_NULL  35
+#define DUK_TOK_TRUE  36
+#define DUK_TOK_FALSE 37
 
 /* reserved words: additional future reserved words in strict mode */
-#define DUK_TOK_START_STRICT_RESERVED             38  /* inclusive */
-#define DUK_TOK_IMPLEMENTS                        38
-#define DUK_TOK_INTERFACE                         39
-#define DUK_TOK_LET                               40
-#define DUK_TOK_PACKAGE                           41
-#define DUK_TOK_PRIVATE                           42
-#define DUK_TOK_PROTECTED                         43
-#define DUK_TOK_PUBLIC                            44
-#define DUK_TOK_STATIC                            45
-#define DUK_TOK_YIELD                             46
+#define DUK_TOK_START_STRICT_RESERVED 38 /* inclusive */
+#define DUK_TOK_IMPLEMENTS            38
+#define DUK_TOK_INTERFACE             39
+#define DUK_TOK_LET                   40
+#define DUK_TOK_PACKAGE               41
+#define DUK_TOK_PRIVATE               42
+#define DUK_TOK_PROTECTED             43
+#define DUK_TOK_PUBLIC                44
+#define DUK_TOK_STATIC                45
+#define DUK_TOK_YIELD                 46
 
-#define DUK_TOK_END_RESERVED                      47  /* exclusive */
+#define DUK_TOK_END_RESERVED 47 /* 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                               47
-#define DUK_TOK_SET                               48
+#define DUK_TOK_GET 47
+#define DUK_TOK_SET 48
 
 /* punctuators (unlike the spec, also includes "/" and "/=") */
-#define DUK_TOK_LCURLY                            49
-#define DUK_TOK_RCURLY                            50
-#define DUK_TOK_LBRACKET                          51
-#define DUK_TOK_RBRACKET                          52
-#define DUK_TOK_LPAREN                            53
-#define DUK_TOK_RPAREN                            54
-#define DUK_TOK_PERIOD                            55
-#define DUK_TOK_SEMICOLON                         56
-#define DUK_TOK_COMMA                             57
-#define DUK_TOK_LT                                58
-#define DUK_TOK_GT                                59
-#define DUK_TOK_LE                                60
-#define DUK_TOK_GE                                61
-#define DUK_TOK_EQ                                62
-#define DUK_TOK_NEQ                               63
-#define DUK_TOK_SEQ                               64
-#define DUK_TOK_SNEQ                              65
-#define DUK_TOK_ADD                               66
-#define DUK_TOK_SUB                               67
-#define DUK_TOK_MUL                               68
-#define DUK_TOK_DIV                               69
-#define DUK_TOK_MOD                               70
-#define DUK_TOK_EXP                               71
-#define DUK_TOK_INCREMENT                         72
-#define DUK_TOK_DECREMENT                         73
-#define DUK_TOK_ALSHIFT                           74   /* named "arithmetic" because result is signed */
-#define DUK_TOK_ARSHIFT                           75
-#define DUK_TOK_RSHIFT                            76
-#define DUK_TOK_BAND                              77
-#define DUK_TOK_BOR                               78
-#define DUK_TOK_BXOR                              79
-#define DUK_TOK_LNOT                              80
-#define DUK_TOK_BNOT                              81
-#define DUK_TOK_LAND                              82
-#define DUK_TOK_LOR                               83
-#define DUK_TOK_QUESTION                          84
-#define DUK_TOK_COLON                             85
-#define DUK_TOK_EQUALSIGN                         86
-#define DUK_TOK_ADD_EQ                            87
-#define DUK_TOK_SUB_EQ                            88
-#define DUK_TOK_MUL_EQ                            89
-#define DUK_TOK_DIV_EQ                            90
-#define DUK_TOK_MOD_EQ                            91
-#define DUK_TOK_EXP_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
+#define DUK_TOK_LCURLY     49
+#define DUK_TOK_RCURLY     50
+#define DUK_TOK_LBRACKET   51
+#define DUK_TOK_RBRACKET   52
+#define DUK_TOK_LPAREN     53
+#define DUK_TOK_RPAREN     54
+#define DUK_TOK_PERIOD     55
+#define DUK_TOK_SEMICOLON  56
+#define DUK_TOK_COMMA      57
+#define DUK_TOK_LT         58
+#define DUK_TOK_GT         59
+#define DUK_TOK_LE         60
+#define DUK_TOK_GE         61
+#define DUK_TOK_EQ         62
+#define DUK_TOK_NEQ        63
+#define DUK_TOK_SEQ        64
+#define DUK_TOK_SNEQ       65
+#define DUK_TOK_ADD        66
+#define DUK_TOK_SUB        67
+#define DUK_TOK_MUL        68
+#define DUK_TOK_DIV        69
+#define DUK_TOK_MOD        70
+#define DUK_TOK_EXP        71
+#define DUK_TOK_INCREMENT  72
+#define DUK_TOK_DECREMENT  73
+#define DUK_TOK_ALSHIFT    74 /* named "arithmetic" because result is signed */
+#define DUK_TOK_ARSHIFT    75
+#define DUK_TOK_RSHIFT     76
+#define DUK_TOK_BAND       77
+#define DUK_TOK_BOR        78
+#define DUK_TOK_BXOR       79
+#define DUK_TOK_LNOT       80
+#define DUK_TOK_BNOT       81
+#define DUK_TOK_LAND       82
+#define DUK_TOK_LOR        83
+#define DUK_TOK_QUESTION   84
+#define DUK_TOK_COLON      85
+#define DUK_TOK_EQUALSIGN  86
+#define DUK_TOK_ADD_EQ     87
+#define DUK_TOK_SUB_EQ     88
+#define DUK_TOK_MUL_EQ     89
+#define DUK_TOK_DIV_EQ     90
+#define DUK_TOK_MOD_EQ     91
+#define DUK_TOK_EXP_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_NUMBER 99
+#define DUK_TOK_STRING 100
+#define DUK_TOK_REGEXP 101
 
-#define DUK_TOK_MAXVAL                            101  /* inclusive */
+#define DUK_TOK_MAXVAL 101 /* inclusive */
 
-#define DUK_TOK_INVALID                           DUK_SMALL_UINT_MAX
+#define DUK_TOK_INVALID DUK_SMALL_UINT_MAX
 
 /* Convert heap string index to a token (reserved words) */
-#define DUK_STRIDX_TO_TOK(x)                        ((x) - DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED)
+#define DUK_STRIDX_TO_TOK(x) ((x) -DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED)
 
 /* Sanity check */
 #if (DUK_TOK_MAXVAL > 255)
@@ -4039,57 +4134,57 @@
 #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  /* assumptions in regexp compiler */
-#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
+#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 /* assumptions in regexp compiler */
+#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_LIMIT                   256
+#define DUK_LEXER_TEMP_BUF_LIMIT 256
 
 /* A token value.  Can be memcpy()'d, but note that slot1/slot2 values are on the valstack.
  * Some fields (like num, str1, str2) are only valid for specific token types and may have
  * stale values otherwise.
  */
 struct duk_token {
-	duk_small_uint_t t;           /* token type (with reserved word identification) */
-	duk_small_uint_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->slot2_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) */
+	duk_small_uint_t t; /* token type (with reserved word identification) */
+	duk_small_uint_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->slot2_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)
+#define DUK_RE_QUANTIFIER_INFINITE ((duk_uint32_t) 0xffffffffUL)
 
 /* A regexp token value. */
 struct duk_re_token {
-	duk_small_uint_t t;          /* token type */
+	duk_small_uint_t t; /* token type */
 	duk_small_uint_t greedy;
-	duk_uint32_t num;            /* numeric value (character, count) */
+	duk_uint32_t num; /* numeric value (character, count) */
 	duk_uint32_t qmin;
 	duk_uint32_t qmax;
 };
@@ -4116,23 +4211,23 @@
 	duk_lexer_codepoint window[DUK_LEXER_WINDOW_SIZE]; /* unicode code points, window[0] is always next */
 #endif
 
-	duk_hthread *thr;                              /* thread; minimizes argument passing */
+	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_int_t input_line;                          /* input linenumber at input_offset (not window[0]), init to 1 */
+	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_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 */
-	duk_bufwriter_ctx bw;                          /* bufwriter for temp accumulation */
+	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 */
+	duk_bufwriter_ctx bw; /* bufwriter for temp accumulation */
 
-	duk_int_t token_count;                         /* number of tokens parsed */
-	duk_int_t token_limit;                         /* maximum token count before error (sanity backstop) */
+	duk_int_t token_count; /* number of tokens parsed */
+	duk_int_t token_limit; /* maximum token count before error (sanity backstop) */
 
-	duk_small_uint_t flags;                        /* lexer flags, use compiler flag defines for now */
+	duk_small_uint_t flags; /* lexer flags, use compiler flag defines for now */
 };
 
 /*
@@ -4145,16 +4240,13 @@
 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);
+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);
 #if defined(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_USE_REGEXP_SUPPORT */
 
-#endif  /* DUK_LEXER_H_INCLUDED */
+#endif /* DUK_LEXER_H_INCLUDED */
 /* #include duk_js_compiler.h */
 #line 1 "duk_js_compiler.h"
 /*
@@ -4165,13 +4257,13 @@
 #define DUK_JS_COMPILER_H_INCLUDED
 
 /* ECMAScript compiler limits */
-#define DUK_COMPILER_TOKEN_LIMIT           100000000L  /* 1e8: protects against deeply nested inner functions */
+#define DUK_COMPILER_TOKEN_LIMIT 100000000L /* 1e8: protects against deeply nested inner functions */
 
 /* maximum loopcount for peephole optimization */
-#define DUK_COMPILER_PEEPHOLE_MAXITER      3
+#define DUK_COMPILER_PEEPHOLE_MAXITER 3
 
 /* maximum bytecode length in instructions */
-#define DUK_COMPILER_MAX_BYTECODE_LENGTH   (256L * 1024L * 1024L)  /* 1 GB */
+#define DUK_COMPILER_MAX_BYTECODE_LENGTH (256L * 1024L * 1024L) /* 1 GB */
 
 /*
  *  Compiler intermediate values
@@ -4181,21 +4273,21 @@
  *  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_PROP          3   /* property access */
-#define DUK_IVAL_VAR           4   /* variable access */
+#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_PROP  3 /* property access */
+#define DUK_IVAL_VAR   4 /* 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 */
+#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.
  * Chosen so that when a regconst is cast to duk_int32_t, all consts are
  * negative values.
  */
-#define DUK_REGCONST_CONST_MARKER    DUK_INT32_MIN  /* = -0x80000000 */
+#define DUK_REGCONST_CONST_MARKER DUK_INT32_MIN /* = -0x80000000 */
 
 /* Type to represent a reg/const reference during compilation, with <0
  * indicating a constant.  Some call sites also use -1 to indicate 'none'.
@@ -4203,9 +4295,9 @@
 typedef duk_int32_t duk_regconst_t;
 
 typedef struct {
-	duk_small_uint_t t;          /* DUK_ISPEC_XXX */
+	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_idx_t valstack_idx; /* always set; points to a reserved valstack slot */
 } duk_ispec;
 
 typedef struct {
@@ -4217,8 +4309,8 @@
 	 */
 
 	/* 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 for binary ops */
+	duk_small_uint_t t; /* DUK_IVAL_XXX */
+	duk_small_uint_t op; /* bytecode opcode for binary ops */
 	duk_ispec x1;
 	duk_ispec x2;
 } duk_ivalue;
@@ -4240,22 +4332,22 @@
  *  Compiler state
  */
 
-#define DUK_LABEL_FLAG_ALLOW_BREAK       (1U << 0)
-#define DUK_LABEL_FLAG_ALLOW_CONTINUE    (1U << 1)
+#define DUK_LABEL_FLAG_ALLOW_BREAK    (1U << 0)
+#define DUK_LABEL_FLAG_ALLOW_CONTINUE (1U << 1)
 
-#define DUK_DECL_TYPE_VAR                0
-#define DUK_DECL_TYPE_FUNC               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
-	                              */
+	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
@@ -4271,22 +4363,22 @@
 	 * platforms (e.g. if int is 32 bits and pointers are 64 bits).
 	 */
 
-	duk_bufwriter_ctx bw_code;          /* bufwriter for code */
+	duk_bufwriter_ctx bw_code; /* bufwriter for code */
 
-	duk_hstring *h_name;                /* function name (borrowed reference), ends up in _name */
+	duk_hstring *h_name; /* function name (borrowed reference), ends up in _name */
 	/* h_code: held in bw_code */
-	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)) */
+	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. */
 	/* code_idx: not needed */
@@ -4299,9 +4391,9 @@
 	duk_idx_t varmap_idx;
 
 	/* Temp reg handling. */
-	duk_regconst_t temp_first;           /* first register that is a temporary (below: variables) */
-	duk_regconst_t temp_next;            /* next temporary register to allocate */
-	duk_regconst_t temp_max;             /* highest value of temp_reg (temp_max - 1 is highest used reg) */
+	duk_regconst_t temp_first; /* first register that is a temporary (below: variables) */
+	duk_regconst_t temp_next; /* next temporary register to allocate */
+	duk_regconst_t temp_max; /* highest value of temp_reg (temp_max - 1 is highest used reg) */
 
 	/* Shuffle registers if large number of regs/consts. */
 	duk_regconst_t shuffle1;
@@ -4311,49 +4403,51 @@
 	/* 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 */
+	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_regconst_t reg_stmt_value;      /* register for writing value of 'non-empty' statements (global or eval code), -1 is marker */
+	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_regconst_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_hcompfunc has duk_uint32_t) */
+	duk_int_t min_line; /* XXX: typing (duk_hcompfunc has duk_uint32_t) */
 	duk_int_t max_line;
 #endif
 
 	/* Status booleans. */
-	duk_uint8_t is_function;             /* is an actual function (not global/eval code) */
-	duk_uint8_t is_eval;                 /* is eval code */
-	duk_uint8_t is_global;               /* is global code */
-	duk_uint8_t is_namebinding;          /* needs a name binding */
-	duk_uint8_t is_constructable;        /* result is constructable */
-	duk_uint8_t is_setget;               /* is a setter/getter */
-	duk_uint8_t is_strict;               /* function is strict */
-	duk_uint8_t is_notail;               /* function must not be tail called */
-	duk_uint8_t in_directive_prologue;   /* parsing in "directive prologue", recognize directives */
-	duk_uint8_t in_scanning;             /* parsing in "scanning" phase (first pass) */
-	duk_uint8_t may_direct_eval;         /* function may call direct eval */
-	duk_uint8_t id_access_arguments;     /* function refers to 'arguments' identifier */
-	duk_uint8_t id_access_slow;          /* function makes one or more slow path accesses that won't match own static variables */
-	duk_uint8_t id_access_slow_own;      /* function makes one or more slow path accesses that may match own static variables */
-	duk_uint8_t is_arguments_shadowed;   /* argument/function declaration shadows 'arguments' */
-	duk_uint8_t needs_shuffle;           /* function needs shuffle registers */
-	duk_uint8_t reject_regexp_in_adv;    /* reject RegExp literal on next advance() call; needed for handling IdentifierName productions */
-	duk_uint8_t allow_regexp_in_adv;     /* allow RegExp literal on next advance() call */
+	duk_uint8_t is_function; /* is an actual function (not global/eval code) */
+	duk_uint8_t is_eval; /* is eval code */
+	duk_uint8_t is_global; /* is global code */
+	duk_uint8_t is_namebinding; /* needs a name binding */
+	duk_uint8_t is_constructable; /* result is constructable */
+	duk_uint8_t is_setget; /* is a setter/getter */
+	duk_uint8_t is_strict; /* function is strict */
+	duk_uint8_t is_notail; /* function must not be tail called */
+	duk_uint8_t in_directive_prologue; /* parsing in "directive prologue", recognize directives */
+	duk_uint8_t in_scanning; /* parsing in "scanning" phase (first pass) */
+	duk_uint8_t may_direct_eval; /* function may call direct eval */
+	duk_uint8_t id_access_arguments; /* function refers to 'arguments' identifier */
+	duk_uint8_t id_access_slow; /* function makes one or more slow path accesses that won't match own static variables */
+	duk_uint8_t id_access_slow_own; /* function makes one or more slow path accesses that may match own static variables */
+	duk_uint8_t is_arguments_shadowed; /* argument/function declaration shadows 'arguments' */
+	duk_uint8_t needs_shuffle; /* function needs shuffle registers */
+	duk_uint8_t
+	    reject_regexp_in_adv; /* reject RegExp literal on next advance() call; needed for handling IdentifierName productions */
+	duk_uint8_t allow_regexp_in_adv; /* allow RegExp literal on next advance() call */
 };
 
 struct duk_compiler_ctx {
 	duk_hthread *thr;
 
 	/* filename being compiled (ends up in functions' '_filename' property) */
-	duk_hstring *h_filename;            /* borrowed reference */
+	duk_hstring *h_filename; /* borrowed reference */
 
 	/* lexing (tokenization) state (contains two valstack slot indices) */
 	duk_lexer_ctx lex;
@@ -4361,10 +4455,10 @@
 	/* 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 */
+	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;
@@ -4381,9 +4475,12 @@
  *  Prototypes
  */
 
-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);
+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 */
+#endif /* DUK_JS_COMPILER_H_INCLUDED */
 /* #include duk_regexp.h */
 #line 1 "duk_regexp.h"
 /*
@@ -4394,39 +4491,39 @@
 #define DUK_REGEXP_H_INCLUDED
 
 /* maximum bytecode copies for {n,m} quantifiers */
-#define DUK_RE_MAX_ATOM_COPIES             1000
+#define DUK_RE_MAX_ATOM_COPIES 1000
 
 /* regexp compilation limits */
-#define DUK_RE_COMPILE_TOKEN_LIMIT         100000000L   /* 1e8 */
+#define DUK_RE_COMPILE_TOKEN_LIMIT 100000000L /* 1e8 */
 
 /* regexp execution limits */
-#define DUK_RE_EXECUTE_STEPS_LIMIT         1000000000L  /* 1e9 */
+#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
+#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                 (1U << 0)
-#define DUK_RE_FLAG_IGNORE_CASE            (1U << 1)
-#define DUK_RE_FLAG_MULTILINE              (1U << 2)
+#define DUK_RE_FLAG_GLOBAL      (1U << 0)
+#define DUK_RE_FLAG_IGNORE_CASE (1U << 1)
+#define DUK_RE_FLAG_MULTILINE   (1U << 2)
 
 struct duk_re_matcher_ctx {
 	duk_hthread *thr;
@@ -4436,7 +4533,7 @@
 	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) */
+	const duk_uint8_t **saved; /* allocated from valstack (fixed buffer) */
 	duk_uint32_t nsaved;
 	duk_uint32_t recursion_depth;
 	duk_uint32_t recursion_limit;
@@ -4451,11 +4548,11 @@
 	duk_lexer_ctx lex;
 	duk_re_token curr_token;
 	duk_bufwriter_ctx bw;
-	duk_uint32_t captures;  /* highest capture number emitted so far (used as: ++captures) */
+	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 */
+	duk_uint32_t nranges; /* internal temporary value, used for char classes */
 };
 
 /*
@@ -4466,10 +4563,10 @@
 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() */
+DUK_INTERNAL_DECL void duk_regexp_match_force_global(duk_hthread *thr); /* hacky helper for String.prototype.split() */
 #endif
 
-#endif  /* DUK_REGEXP_H_INCLUDED */
+#endif /* DUK_REGEXP_H_INCLUDED */
 /* #include duk_heaphdr.h */
 #line 1 "duk_heaphdr.h"
 /*
@@ -4523,7 +4620,7 @@
 #else
 	duk_size_t h_refcount;
 #endif
-#endif  /* DUK_USE_REFERENCE_COUNTING */
+#endif /* DUK_USE_REFERENCE_COUNTING */
 
 #if defined(DUK_USE_HEAPPTR16)
 	duk_uint16_t h_next16;
@@ -4571,7 +4668,7 @@
 #endif
 #if defined(DUK_USE_REFCOUNT16)
 	duk_uint16_t h_refcount;
-	duk_uint16_t h_strextra16;  /* round out to 8 bytes */
+	duk_uint16_t h_strextra16; /* round out to 8 bytes */
 #elif defined(DUK_USE_REFCOUNT32)
 	duk_uint32_t h_refcount;
 #else
@@ -4579,160 +4676,169 @@
 #endif
 #else
 	duk_uint16_t h_strextra16;
-#endif  /* DUK_USE_REFERENCE_COUNTING */
+#endif /* DUK_USE_REFERENCE_COUNTING */
 
 	duk_hstring *h_next;
 	/* No 'h_prev' pointer for strings. */
 };
 
-#define DUK_HEAPHDR_FLAGS_TYPE_MASK      0x00000003UL
-#define DUK_HEAPHDR_FLAGS_FLAG_MASK      (~DUK_HEAPHDR_FLAGS_TYPE_MASK)
+#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   /* 5 heap flags */
-#define DUK_HEAPHDR_FLAGS_USER_START     7   /* 25 user flags */
+/* 2 bits for heap type */
+#define DUK_HEAPHDR_FLAGS_HEAP_START 2 /* 5 heap flags */
+#define DUK_HEAPHDR_FLAGS_USER_START 7 /* 25 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_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_HEAPHDR_FLAG_READONLY        DUK_HEAPHDR_HEAP_FLAG(4)  /* read-only object, in code section */
+#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_HEAPHDR_FLAG_READONLY    DUK_HEAPHDR_HEAP_FLAG(4) /* read-only object, in code section */
 
-#define DUK_HTYPE_MIN                    0
-#define DUK_HTYPE_STRING                 0
-#define DUK_HTYPE_OBJECT                 1
-#define DUK_HTYPE_BUFFER                 2
-#define DUK_HTYPE_MAX                    2
+#define DUK_HTYPE_MIN    0
+#define DUK_HTYPE_STRING 0
+#define DUK_HTYPE_OBJECT 1
+#define DUK_HTYPE_BUFFER 2
+#define DUK_HTYPE_MAX    2
 
 #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 { \
+#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 { \
+#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 { \
+#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 { \
+#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)
-#define DUK_HEAPHDR_GET_REFCOUNT(h)   ((h)->h_refcount)
-#define DUK_HEAPHDR_SET_REFCOUNT(h,val)  do { \
+#define DUK_HEAPHDR_GET_REFCOUNT(h) ((h)->h_refcount)
+#define DUK_HEAPHDR_SET_REFCOUNT(h, val) \
+	do { \
 		(h)->h_refcount = (val); \
-		DUK_ASSERT((h)->h_refcount == (val));  /* No truncation. */ \
+		DUK_ASSERT((h)->h_refcount == (val)); /* No truncation. */ \
 	} 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 */
+#define DUK_HEAPHDR_PREINC_REFCOUNT(h) (++(h)->h_refcount) /* result: updated refcount */
+#define DUK_HEAPHDR_PREDEC_REFCOUNT(h) (--(h)->h_refcount) /* result: updated refcount */
 #else
 /* refcount macros not defined without refcounting, caller must #if defined() now */
-#endif  /* DUK_USE_REFERENCE_COUNTING */
+#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_SET_FLAGS_RAW(h,val)  do { \
-		(h)->h_flags = (val); } \
+#define DUK_HEAPHDR_GET_FLAGS_RAW(h) ((h)->h_flags)
+#define DUK_HEAPHDR_SET_FLAGS_RAW(h, val) \
+	do { \
+		(h)->h_flags = (val); \
+	} \
 	}
-#define DUK_HEAPHDR_GET_FLAGS(h)      ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK)
-#define DUK_HEAPHDR_SET_FLAGS(h,val)  do { \
+#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 { \
+#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)
 
 /* Comparison for type >= DUK_HTYPE_MIN skipped; because DUK_HTYPE_MIN is zero
  * and the comparison is unsigned, it's always true and generates warnings.
  */
-#define DUK_HEAPHDR_HTYPE_VALID(h)    ( \
-	DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \
-	)
+#define DUK_HEAPHDR_HTYPE_VALID(h) (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); \
+#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 { \
+#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 { \
+#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_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_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_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_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)
+#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)
 
-#define DUK_HEAPHDR_SET_READONLY(h)       DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
-#define DUK_HEAPHDR_CLEAR_READONLY(h)     DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
-#define DUK_HEAPHDR_HAS_READONLY(h)       DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_READONLY)
+#define DUK_HEAPHDR_SET_READONLY(h)   DUK_HEAPHDR_SET_FLAG_BITS((h), DUK_HEAPHDR_FLAG_READONLY)
+#define DUK_HEAPHDR_CLEAR_READONLY(h) DUK_HEAPHDR_CLEAR_FLAG_BITS((h), DUK_HEAPHDR_FLAG_READONLY)
+#define DUK_HEAPHDR_HAS_READONLY(h)   DUK_HEAPHDR_CHECK_FLAG_BITS((h), DUK_HEAPHDR_FLAG_READONLY)
 
 /* 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_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 & (~(((1UL << (n)) - 1UL) << (m)))) \
-			| ((v) << (m)); \
+#define DUK_HEAPHDR_SET_FLAG_RANGE(h, m, n, v) \
+	do { \
+		(h)->h_flags = ((h)->h_flags & (~(((1UL << (n)) - 1UL) << (m)))) | ((v) << (m)); \
 	} while (0)
 
 /* init pointer fields to null */
 #if defined(DUK_USE_DOUBLE_LINKED_HEAP)
-#define DUK_HEAPHDR_INIT_NULLS(h)       do { \
+#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 { \
+#define DUK_HEAPHDR_INIT_NULLS(h) \
+	do { \
 		DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
 	} while (0)
 #endif
 
-#define DUK_HEAPHDR_STRING_INIT_NULLS(h)  do { \
+#define DUK_HEAPHDR_STRING_INIT_NULLS(h) \
+	do { \
 		(h)->h_next = NULL; \
 	} while (0)
 
@@ -4761,14 +4867,24 @@
 DUK_INTERNAL_DECL void duk_heaphdr_assert_valid_subclassed(duk_heaphdr *h);
 DUK_INTERNAL_DECL void duk_heaphdr_assert_links(duk_heap *heap, duk_heaphdr *h);
 DUK_INTERNAL_DECL void duk_heaphdr_assert_valid(duk_heaphdr *h);
-#define DUK_HEAPHDR_ASSERT_LINKS(heap,h)  do { duk_heaphdr_assert_links((heap), (h)); } while (0)
-#define DUK_HEAPHDR_ASSERT_VALID(h)  do { duk_heaphdr_assert_valid((h)); } while (0)
+#define DUK_HEAPHDR_ASSERT_LINKS(heap, h) \
+	do { \
+		duk_heaphdr_assert_links((heap), (h)); \
+	} while (0)
+#define DUK_HEAPHDR_ASSERT_VALID(h) \
+	do { \
+		duk_heaphdr_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HEAPHDR_ASSERT_LINKS(heap,h)  do {} while (0)
-#define DUK_HEAPHDR_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HEAPHDR_ASSERT_LINKS(heap, h) \
+	do { \
+	} while (0)
+#define DUK_HEAPHDR_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
-#endif  /* DUK_HEAPHDR_H_INCLUDED */
+#endif /* DUK_HEAPHDR_H_INCLUDED */
 /* #include duk_refcount.h */
 #line 1 "duk_refcount.h"
 /*
@@ -4790,19 +4906,20 @@
 /* XXX: double evaluation for 'tv' argument. */
 #define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv) \
 	(DUK_TVAL_IS_HEAP_ALLOCATED((tv)) && !DUK_HEAPHDR_HAS_READONLY(DUK_TVAL_GET_HEAPHDR((tv))))
-#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h)  (!DUK_HEAPHDR_HAS_READONLY((h)))
-#else  /* DUK_USE_ROM_OBJECTS */
+#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h) (!DUK_HEAPHDR_HAS_READONLY((h)))
+#else /* DUK_USE_ROM_OBJECTS */
 /* Without ROM objects "needs refcount update" == is heap allocated. */
-#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv)    DUK_TVAL_IS_HEAP_ALLOCATED((tv))
-#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h)  1
-#endif  /* DUK_USE_ROM_OBJECTS */
+#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv)   DUK_TVAL_IS_HEAP_ALLOCATED((tv))
+#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h) 1
+#endif /* DUK_USE_ROM_OBJECTS */
 
 /* 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 { \
+#define DUK_TVAL_INCREF_FAST(thr, tv) \
+	do { \
 		duk_tval *duk__tv = (tv); \
 		DUK_ASSERT(duk__tv != NULL); \
 		if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
@@ -4810,10 +4927,11 @@
 			DUK_ASSERT(duk__h != NULL); \
 			DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
 			DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
-			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) != 0);  /* No wrapping. */ \
+			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) != 0); /* No wrapping. */ \
 		} \
 	} while (0)
-#define DUK_TVAL_DECREF_FAST(thr,tv) do { \
+#define DUK_TVAL_DECREF_FAST(thr, tv) \
+	do { \
 		duk_tval *duk__tv = (tv); \
 		DUK_ASSERT(duk__tv != NULL); \
 		if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
@@ -4826,7 +4944,8 @@
 			} \
 		} \
 	} while (0)
-#define DUK_TVAL_DECREF_NORZ_FAST(thr,tv) do { \
+#define DUK_TVAL_DECREF_NORZ_FAST(thr, tv) \
+	do { \
 		duk_tval *duk__tv = (tv); \
 		DUK_ASSERT(duk__tv != NULL); \
 		if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(duk__tv)) { \
@@ -4839,16 +4958,18 @@
 			} \
 		} \
 	} while (0)
-#define DUK_HEAPHDR_INCREF_FAST(thr,h) do { \
+#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)); \
 		if (DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(duk__h)) { \
 			DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
-			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) != 0);  /* No wrapping. */ \
+			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) != 0); /* No wrapping. */ \
 		} \
 	} while (0)
-#define DUK_HEAPHDR_DECREF_FAST_RAW(thr,h,rzcall,rzcast) do { \
+#define DUK_HEAPHDR_DECREF_FAST_RAW(thr, h, rzcall, rzcast) \
+	do { \
 		duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
 		DUK_ASSERT(duk__h != NULL); \
 		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
@@ -4859,29 +4980,72 @@
 			} \
 		} \
 	} while (0)
-#define DUK_HEAPHDR_DECREF_FAST(thr,h) \
-	DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_heaphdr_refzero,duk_heaphdr *)
-#define DUK_HEAPHDR_DECREF_NORZ_FAST(thr,h) \
-	DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_heaphdr_refzero_norz,duk_heaphdr *)
+#define DUK_HEAPHDR_DECREF_FAST(thr, h)      DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_heaphdr_refzero, duk_heaphdr *)
+#define DUK_HEAPHDR_DECREF_NORZ_FAST(thr, h) DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_heaphdr_refzero_norz, duk_heaphdr *)
 
 /* 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_TVAL_DECREF_NORZ_SLOW(thr,tv)    do { duk_tval_decref_norz((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)
-#define DUK_HEAPHDR_DECREF_NORZ_SLOW(thr,h)  do { duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); } while (0)
-#define DUK_HSTRING_INCREF_SLOW(thr,h)       do { duk_heaphdr_incref((duk_heaphdr *) (h)); } while (0)
-#define DUK_HSTRING_DECREF_SLOW(thr,h)       do { duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); } while (0)
-#define DUK_HSTRING_DECREF_NORZ_SLOW(thr,h)  do { duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); } while (0)
-#define DUK_HBUFFER_INCREF_SLOW(thr,h)       do { duk_heaphdr_incref((duk_heaphdr *) (h)); } while (0)
-#define DUK_HBUFFER_DECREF_SLOW(thr,h)       do { duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); } while (0)
-#define DUK_HBUFFER_DECREF_NORZ_SLOW(thr,h)  do { duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); } while (0)
-#define DUK_HOBJECT_INCREF_SLOW(thr,h)       do { duk_heaphdr_incref((duk_heaphdr *) (h)); } while (0)
-#define DUK_HOBJECT_DECREF_SLOW(thr,h)       do { duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); } while (0)
-#define DUK_HOBJECT_DECREF_NORZ_SLOW(thr,h)  do { duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); } while (0)
+#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_TVAL_DECREF_NORZ_SLOW(thr, tv) \
+	do { \
+		duk_tval_decref_norz((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)
+#define DUK_HEAPHDR_DECREF_NORZ_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HSTRING_INCREF_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_incref((duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HSTRING_DECREF_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HSTRING_DECREF_NORZ_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HBUFFER_INCREF_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_incref((duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HBUFFER_DECREF_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HBUFFER_DECREF_NORZ_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_decref_norz((thr), (duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HOBJECT_INCREF_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_incref((duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HOBJECT_DECREF_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
+	} while (0)
+#define DUK_HOBJECT_DECREF_NORZ_SLOW(thr, h) \
+	do { \
+		duk_heaphdr_decref_norz((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
@@ -4891,122 +5055,136 @@
 /* XXX: It would be nice to specialize for specific duk_hobject subtypes
  * but current refzero queue handling prevents that.
  */
-#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_TVAL_DECREF_NORZ(thr,tv)           DUK_TVAL_DECREF_NORZ_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_RAW((thr),(h),duk_heaphdr_refzero,duk_heaphdr *)
-#define DUK_HEAPHDR_DECREF_NORZ(thr,h)         DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_heaphdr_refzero_norz,duk_heaphdr *)
-#define DUK_HSTRING_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HSTRING_DECREF(thr,h)              DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hstring_refzero,duk_hstring *)
-#define DUK_HSTRING_DECREF_NORZ(thr,h)         DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hstring_refzero,duk_hstring *)  /* no 'norz' variant */
-#define DUK_HOBJECT_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HOBJECT_DECREF(thr,h)              DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
-#define DUK_HOBJECT_DECREF_NORZ(thr,h)         DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
-#define DUK_HBUFFER_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HBUFFER_DECREF(thr,h)              DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hbuffer_refzero,duk_hbuffer *)
-#define DUK_HBUFFER_DECREF_NORZ(thr,h)         DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hbuffer_refzero,duk_hbuffer *)  /* no 'norz' variant */
-#define DUK_HCOMPFUNC_INCREF(thr,h)            DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HCOMPFUNC_DECREF(thr,h)            DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
-#define DUK_HCOMPFUNC_DECREF_NORZ(thr,h)       DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
-#define DUK_HNATFUNC_INCREF(thr,h)             DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HNATFUNC_DECREF(thr,h)             DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
-#define DUK_HNATFUNC_DECREF_NORZ(thr,h)        DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
-#define DUK_HBUFOBJ_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HBUFOBJ_DECREF(thr,h)              DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
-#define DUK_HBUFOBJ_DECREF_NORZ(thr,h)         DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
-#define DUK_HTHREAD_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HTHREAD_DECREF(thr,h)              DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero,duk_hobject *)
-#define DUK_HTHREAD_DECREF_NORZ(thr,h)         DUK_HEAPHDR_DECREF_FAST_RAW((thr),(h),duk_hobject_refzero_norz,duk_hobject *)
+#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_TVAL_DECREF_NORZ(thr, tv)   DUK_TVAL_DECREF_NORZ_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_RAW((thr), (h), duk_heaphdr_refzero, duk_heaphdr *)
+#define DUK_HEAPHDR_DECREF_NORZ(thr, h) DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_heaphdr_refzero_norz, duk_heaphdr *)
+#define DUK_HSTRING_INCREF(thr, h)      DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h))
+#define DUK_HSTRING_DECREF(thr, h)      DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hstring_refzero, duk_hstring *)
+#define DUK_HSTRING_DECREF_NORZ(thr, h) \
+	DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hstring_refzero, duk_hstring *) /* no 'norz' variant */
+#define DUK_HOBJECT_INCREF(thr, h)      DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h))
+#define DUK_HOBJECT_DECREF(thr, h)      DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *)
+#define DUK_HOBJECT_DECREF_NORZ(thr, h) DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *)
+#define DUK_HBUFFER_INCREF(thr, h)      DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h))
+#define DUK_HBUFFER_DECREF(thr, h)      DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hbuffer_refzero, duk_hbuffer *)
+#define DUK_HBUFFER_DECREF_NORZ(thr, h) \
+	DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hbuffer_refzero, duk_hbuffer *) /* no 'norz' variant */
+#define DUK_HCOMPFUNC_INCREF(thr, h)      DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj)
+#define DUK_HCOMPFUNC_DECREF(thr, h)      DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *)
+#define DUK_HCOMPFUNC_DECREF_NORZ(thr, h) DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *)
+#define DUK_HNATFUNC_INCREF(thr, h)       DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj)
+#define DUK_HNATFUNC_DECREF(thr, h)       DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *)
+#define DUK_HNATFUNC_DECREF_NORZ(thr, h)  DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *)
+#define DUK_HBUFOBJ_INCREF(thr, h)        DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj)
+#define DUK_HBUFOBJ_DECREF(thr, h)        DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *)
+#define DUK_HBUFOBJ_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *)
+#define DUK_HTHREAD_INCREF(thr, h)        DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj)
+#define DUK_HTHREAD_DECREF(thr, h)        DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero, duk_hobject *)
+#define DUK_HTHREAD_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_FAST_RAW((thr), (h), duk_hobject_refzero_norz, duk_hobject *)
 #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_TVAL_DECREF_NORZ(thr,tv)           DUK_TVAL_DECREF_NORZ_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))
-#define DUK_HEAPHDR_DECREF_NORZ(thr,h)         DUK_HEAPHDR_DECREF_NORZ_SLOW((thr),(h))
-#define DUK_HSTRING_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HSTRING_DECREF(thr,h)              DUK_HSTRING_DECREF_SLOW((thr),(h))
-#define DUK_HSTRING_DECREF_NORZ(thr,h)         DUK_HSTRING_DECREF_NORZ_SLOW((thr),(h))
-#define DUK_HOBJECT_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HOBJECT_DECREF(thr,h)              DUK_HOBJECT_DECREF_SLOW((thr),(h))
-#define DUK_HOBJECT_DECREF_NORZ(thr,h)         DUK_HOBJECT_DECREF_NORZ_SLOW((thr),(h))
-#define DUK_HBUFFER_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
-#define DUK_HBUFFER_DECREF(thr,h)              DUK_HBUFFER_DECREF_SLOW((thr),(h))
-#define DUK_HBUFFER_DECREF_NORZ(thr,h)         DUK_HBUFFER_DECREF_NORZ_SLOW((thr),(h))
-#define DUK_HCOMPFUNC_INCREF(thr,h)            DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HCOMPFUNC_DECREF(thr,h)            DUK_HOBJECT_DECREF_SLOW((thr),(duk_hobject *) &(h)->obj)
-#define DUK_HCOMPFUNC_DECREF_NORZ(thr,h)       DUK_HOBJECT_DECREF_NORZ_SLOW((thr),(duk_hobject *) &(h)->obj)
-#define DUK_HNATFUNC_INCREF(thr,h)             DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HNATFUNC_DECREF(thr,h)             DUK_HOBJECT_DECREF_SLOW((thr),(duk_hobject *) &(h)->obj)
-#define DUK_HNATFUNC_DECREF_NORZ(thr,h)        DUK_HOBJECT_DECREF_NORZ_SLOW((thr),(duk_hobject *) &(h)->obj)
-#define DUK_HBUFOBJ_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HBUFOBJ_DECREF(thr,h)              DUK_HOBJECT_DECREF_SLOW((thr),(duk_hobject *) &(h)->obj)
-#define DUK_HBUFOB_DECREF_NORZ(thr,h)          DUK_HOBJECT_DECREF_NORZ_SLOW((thr),(duk_hobject *) &(h)->obj)
-#define DUK_HTHREAD_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
-#define DUK_HTHREAD_DECREF(thr,h)              DUK_HOBJECT_DECREF_SLOW((thr),(duk_hobject *) &(h)->obj)
-#define DUK_HTHREAD_DECREF_NORZ(thr,h)         DUK_HOBJECT_DECREF_NORZ_SLOW((thr),(duk_hobject *) &(h)->obj)
+#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_TVAL_DECREF_NORZ(thr, tv)     DUK_TVAL_DECREF_NORZ_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))
+#define DUK_HEAPHDR_DECREF_NORZ(thr, h)   DUK_HEAPHDR_DECREF_NORZ_SLOW((thr), (h))
+#define DUK_HSTRING_INCREF(thr, h)        DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h))
+#define DUK_HSTRING_DECREF(thr, h)        DUK_HSTRING_DECREF_SLOW((thr), (h))
+#define DUK_HSTRING_DECREF_NORZ(thr, h)   DUK_HSTRING_DECREF_NORZ_SLOW((thr), (h))
+#define DUK_HOBJECT_INCREF(thr, h)        DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h))
+#define DUK_HOBJECT_DECREF(thr, h)        DUK_HOBJECT_DECREF_SLOW((thr), (h))
+#define DUK_HOBJECT_DECREF_NORZ(thr, h)   DUK_HOBJECT_DECREF_NORZ_SLOW((thr), (h))
+#define DUK_HBUFFER_INCREF(thr, h)        DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h))
+#define DUK_HBUFFER_DECREF(thr, h)        DUK_HBUFFER_DECREF_SLOW((thr), (h))
+#define DUK_HBUFFER_DECREF_NORZ(thr, h)   DUK_HBUFFER_DECREF_NORZ_SLOW((thr), (h))
+#define DUK_HCOMPFUNC_INCREF(thr, h)      DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj)
+#define DUK_HCOMPFUNC_DECREF(thr, h)      DUK_HOBJECT_DECREF_SLOW((thr), (duk_hobject *) &(h)->obj)
+#define DUK_HCOMPFUNC_DECREF_NORZ(thr, h) DUK_HOBJECT_DECREF_NORZ_SLOW((thr), (duk_hobject *) &(h)->obj)
+#define DUK_HNATFUNC_INCREF(thr, h)       DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj)
+#define DUK_HNATFUNC_DECREF(thr, h)       DUK_HOBJECT_DECREF_SLOW((thr), (duk_hobject *) &(h)->obj)
+#define DUK_HNATFUNC_DECREF_NORZ(thr, h)  DUK_HOBJECT_DECREF_NORZ_SLOW((thr), (duk_hobject *) &(h)->obj)
+#define DUK_HBUFOBJ_INCREF(thr, h)        DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj)
+#define DUK_HBUFOBJ_DECREF(thr, h)        DUK_HOBJECT_DECREF_SLOW((thr), (duk_hobject *) &(h)->obj)
+#define DUK_HBUFOB_DECREF_NORZ(thr, h)    DUK_HOBJECT_DECREF_NORZ_SLOW((thr), (duk_hobject *) &(h)->obj)
+#define DUK_HTHREAD_INCREF(thr, h)        DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) &(h)->obj)
+#define DUK_HTHREAD_DECREF(thr, h)        DUK_HOBJECT_DECREF_SLOW((thr), (duk_hobject *) &(h)->obj)
+#define DUK_HTHREAD_DECREF_NORZ(thr, h)   DUK_HOBJECT_DECREF_NORZ_SLOW((thr), (duk_hobject *) &(h)->obj)
 #endif
 
 /* Convenience for some situations; the above macros don't allow NULLs
  * for performance reasons.  Macros cover only actually needed cases.
  */
-#define DUK_HEAPHDR_INCREF_ALLOWNULL(thr,h) do { \
+#define DUK_HEAPHDR_INCREF_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \
 		} \
 	} while (0)
-#define DUK_HEAPHDR_DECREF_ALLOWNULL(thr,h) do { \
+#define DUK_HEAPHDR_DECREF_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \
 		} \
 	} while (0)
-#define DUK_HEAPHDR_DECREF_NORZ_ALLOWNULL(thr,h) do { \
+#define DUK_HEAPHDR_DECREF_NORZ_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HEAPHDR_DECREF_NORZ((thr), (duk_heaphdr *) (h)); \
 		} \
 	} while (0)
-#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do { \
+#define DUK_HOBJECT_INCREF_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HOBJECT_INCREF((thr), (h)); \
 		} \
 	} while (0)
-#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do { \
+#define DUK_HOBJECT_DECREF_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HOBJECT_DECREF((thr), (h)); \
 		} \
 	} while (0)
-#define DUK_HOBJECT_DECREF_NORZ_ALLOWNULL(thr,h) do { \
+#define DUK_HOBJECT_DECREF_NORZ_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HOBJECT_DECREF_NORZ((thr), (h)); \
 		} \
 	} while (0)
-#define DUK_HBUFFER_INCREF_ALLOWNULL(thr,h) do { \
+#define DUK_HBUFFER_INCREF_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HBUFFER_INCREF((thr), (h)); \
 		} \
 	} while (0)
-#define DUK_HBUFFER_DECREF_ALLOWNULL(thr,h) do { \
+#define DUK_HBUFFER_DECREF_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HBUFFER_DECREF((thr), (h)); \
 		} \
 	} while (0)
-#define DUK_HBUFFER_DECREF_NORZ_ALLOWNULL(thr,h) do { \
+#define DUK_HBUFFER_DECREF_NORZ_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HBUFFER_DECREF_NORZ((thr), (h)); \
 		} \
 	} while (0)
-#define DUK_HTHREAD_INCREF_ALLOWNULL(thr,h) do { \
+#define DUK_HTHREAD_INCREF_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HTHREAD_INCREF((thr), (h)); \
 		} \
 	} while (0)
-#define DUK_HTHREAD_DECREF_ALLOWNULL(thr,h) do { \
+#define DUK_HTHREAD_DECREF_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HTHREAD_DECREF((thr), (h)); \
 		} \
 	} while (0)
-#define DUK_HTHREAD_DECREF_NORZ_ALLOWNULL(thr,h) do { \
+#define DUK_HTHREAD_DECREF_NORZ_ALLOWNULL(thr, h) \
+	do { \
 		if ((h) != NULL) { \
 			DUK_HTHREAD_DECREF_NORZ((thr), (h)); \
 		} \
@@ -5018,16 +5196,22 @@
  * variant is performance critical.
  */
 #if defined(DUK_USE_FINALIZER_SUPPORT)
-#define DUK_REFZERO_CHECK_FAST(thr) do { \
+#define DUK_REFZERO_CHECK_FAST(thr) \
+	do { \
 		duk_refzero_check_fast((thr)); \
 	} while (0)
-#define DUK_REFZERO_CHECK_SLOW(thr) do { \
+#define DUK_REFZERO_CHECK_SLOW(thr) \
+	do { \
 		duk_refzero_check_slow((thr)); \
 	} while (0)
-#else  /* DUK_USE_FINALIZER_SUPPORT */
-#define DUK_REFZERO_CHECK_FAST(thr) do { } while (0)
-#define DUK_REFZERO_CHECK_SLOW(thr) do { } while (0)
-#endif  /* DUK_USE_FINALIZER_SUPPORT */
+#else /* DUK_USE_FINALIZER_SUPPORT */
+#define DUK_REFZERO_CHECK_FAST(thr) \
+	do { \
+	} while (0)
+#define DUK_REFZERO_CHECK_SLOW(thr) \
+	do { \
+	} while (0)
+#endif /* DUK_USE_FINALIZER_SUPPORT */
 
 /*
  *  Macros to set a duk_tval and update refcount of the target (decref the
@@ -5035,125 +5219,176 @@
  *  and footprint critical; any changes made should be measured for size/speed.
  */
 
-#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_UNDEFINED(tv__dst); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
-#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_UNDEFINED(tv__dst); \
 		DUK_TVAL_DECREF_NORZ((thr), &tv__tmp); \
 	} while (0)
 
-#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_UNUSED(tv__dst); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
-#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_NULL(tv__dst); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
-#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
-#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
-#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
-#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
-#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_NAN(tv__dst); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 #if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_I48_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_I48_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_I48(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
-#define DUK_TVAL_SET_I32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_I32_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_I32(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
-#define DUK_TVAL_SET_U32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_U32_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_U32(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 #else
-#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr,tvptr_dst,newval) \
+#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr, tvptr_dst, newval) \
 	DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))
-#endif  /* DUK_USE_FASTINT */
+#endif /* DUK_USE_FASTINT */
 
-#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr, tvptr_dst, lf_v, lf_fp, lf_flags) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
-#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_STRING(tv__dst, (newval)); \
 		DUK_HSTRING_INCREF((thr), (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
-#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
 		DUK_HOBJECT_INCREF((thr), (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
-#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
 		DUK_HBUFFER_INCREF((thr), (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
-#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; duk_tval tv__tmp; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
 /* DUK_TVAL_SET_TVAL_UPDREF() is used a lot in executor, property lookups,
@@ -5164,281 +5399,452 @@
  */
 
 /* Original idiom used, minimal code size. */
-#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \
-		duk_tval *tv__dst, *tv__src; duk_tval tv__tmp; \
-		tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
+#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr, tvptr_dst, tvptr_src) \
+	do { \
+		duk_tval *tv__dst, *tv__src; \
+		duk_tval tv__tmp; \
+		tv__dst = (tvptr_dst); \
+		tv__src = (tvptr_src); \
 		DUK_TVAL_SET_TVAL(&tv__tmp, tv__dst); \
 		DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
 		DUK_TVAL_INCREF((thr), tv__src); \
-		DUK_TVAL_DECREF((thr), &tv__tmp);  /* side effects */ \
+		DUK_TVAL_DECREF((thr), &tv__tmp); /* side effects */ \
 	} while (0)
 
 /* Faster alternative: avoid making a temporary copy of tvptr_dst and use
  * fast incref/decref macros.
  */
-#define DUK_TVAL_SET_TVAL_UPDREF_ALT1(thr,tvptr_dst,tvptr_src) do { \
-		duk_tval *tv__dst, *tv__src; duk_heaphdr *h__obj; \
-		tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
+#define DUK_TVAL_SET_TVAL_UPDREF_ALT1(thr, tvptr_dst, tvptr_src) \
+	do { \
+		duk_tval *tv__dst, *tv__src; \
+		duk_heaphdr *h__obj; \
+		tv__dst = (tvptr_dst); \
+		tv__src = (tvptr_src); \
 		DUK_TVAL_INCREF_FAST((thr), tv__src); \
 		if (DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv__dst)) { \
 			h__obj = DUK_TVAL_GET_HEAPHDR(tv__dst); \
 			DUK_ASSERT(h__obj != NULL); \
 			DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
-			DUK_HEAPHDR_DECREF_FAST((thr), h__obj);  /* side effects */ \
+			DUK_HEAPHDR_DECREF_FAST((thr), h__obj); /* side effects */ \
 		} else { \
 			DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
 		} \
 	} while (0)
 
 /* XXX: no optimized variants yet */
-#define DUK_TVAL_SET_UNDEFINED_UPDREF         DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
-#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ    DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0
-#define DUK_TVAL_SET_UNUSED_UPDREF            DUK_TVAL_SET_UNUSED_UPDREF_ALT0
-#define DUK_TVAL_SET_NULL_UPDREF              DUK_TVAL_SET_NULL_UPDREF_ALT0
-#define DUK_TVAL_SET_BOOLEAN_UPDREF           DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
-#define DUK_TVAL_SET_NUMBER_UPDREF            DUK_TVAL_SET_NUMBER_UPDREF_ALT0
-#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF    DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
-#define DUK_TVAL_SET_DOUBLE_UPDREF            DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
-#define DUK_TVAL_SET_NAN_UPDREF               DUK_TVAL_SET_NAN_UPDREF_ALT0
+#define DUK_TVAL_SET_UNDEFINED_UPDREF      DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
+#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ_ALT0
+#define DUK_TVAL_SET_UNUSED_UPDREF         DUK_TVAL_SET_UNUSED_UPDREF_ALT0
+#define DUK_TVAL_SET_NULL_UPDREF           DUK_TVAL_SET_NULL_UPDREF_ALT0
+#define DUK_TVAL_SET_BOOLEAN_UPDREF        DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
+#define DUK_TVAL_SET_NUMBER_UPDREF         DUK_TVAL_SET_NUMBER_UPDREF_ALT0
+#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
+#define DUK_TVAL_SET_DOUBLE_UPDREF         DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
+#define DUK_TVAL_SET_NAN_UPDREF            DUK_TVAL_SET_NAN_UPDREF_ALT0
 #if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_I48_UPDREF               DUK_TVAL_SET_I48_UPDREF_ALT0
-#define DUK_TVAL_SET_I32_UPDREF               DUK_TVAL_SET_I32_UPDREF_ALT0
-#define DUK_TVAL_SET_U32_UPDREF               DUK_TVAL_SET_U32_UPDREF_ALT0
+#define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_I48_UPDREF_ALT0
+#define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_I32_UPDREF_ALT0
+#define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_U32_UPDREF_ALT0
 #else
-#define DUK_TVAL_SET_I48_UPDREF               DUK_TVAL_SET_DOUBLE_CAST_UPDREF  /* XXX: fast int-to-double */
-#define DUK_TVAL_SET_I32_UPDREF               DUK_TVAL_SET_DOUBLE_CAST_UPDREF
-#define DUK_TVAL_SET_U32_UPDREF               DUK_TVAL_SET_DOUBLE_CAST_UPDREF
-#endif  /* DUK_USE_FASTINT */
-#define DUK_TVAL_SET_FASTINT_UPDREF           DUK_TVAL_SET_I48_UPDREF  /* convenience */
-#define DUK_TVAL_SET_LIGHTFUNC_UPDREF         DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
-#define DUK_TVAL_SET_STRING_UPDREF            DUK_TVAL_SET_STRING_UPDREF_ALT0
-#define DUK_TVAL_SET_OBJECT_UPDREF            DUK_TVAL_SET_OBJECT_UPDREF_ALT0
-#define DUK_TVAL_SET_BUFFER_UPDREF            DUK_TVAL_SET_BUFFER_UPDREF_ALT0
-#define DUK_TVAL_SET_POINTER_UPDREF           DUK_TVAL_SET_POINTER_UPDREF_ALT0
+#define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF /* XXX: fast int-to-double */
+#define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF
+#define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF
+#endif /* DUK_USE_FASTINT */
+#define DUK_TVAL_SET_FASTINT_UPDREF   DUK_TVAL_SET_I48_UPDREF /* convenience */
+#define DUK_TVAL_SET_LIGHTFUNC_UPDREF DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
+#define DUK_TVAL_SET_STRING_UPDREF    DUK_TVAL_SET_STRING_UPDREF_ALT0
+#define DUK_TVAL_SET_OBJECT_UPDREF    DUK_TVAL_SET_OBJECT_UPDREF_ALT0
+#define DUK_TVAL_SET_BUFFER_UPDREF    DUK_TVAL_SET_BUFFER_UPDREF_ALT0
+#define DUK_TVAL_SET_POINTER_UPDREF   DUK_TVAL_SET_POINTER_UPDREF_ALT0
 
 #if defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
 /* Optimized for speed. */
-#define DUK_TVAL_SET_TVAL_UPDREF              DUK_TVAL_SET_TVAL_UPDREF_ALT1
-#define DUK_TVAL_SET_TVAL_UPDREF_FAST         DUK_TVAL_SET_TVAL_UPDREF_ALT1
-#define DUK_TVAL_SET_TVAL_UPDREF_SLOW         DUK_TVAL_SET_TVAL_UPDREF_ALT0
+#define DUK_TVAL_SET_TVAL_UPDREF      DUK_TVAL_SET_TVAL_UPDREF_ALT1
+#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT1
+#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0
 #else
 /* Optimized for size. */
-#define DUK_TVAL_SET_TVAL_UPDREF              DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#define DUK_TVAL_SET_TVAL_UPDREF_FAST         DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#define DUK_TVAL_SET_TVAL_UPDREF_SLOW         DUK_TVAL_SET_TVAL_UPDREF_ALT0
+#define DUK_TVAL_SET_TVAL_UPDREF      DUK_TVAL_SET_TVAL_UPDREF_ALT0
+#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT0
+#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0
 #endif
 
-#else  /* DUK_USE_REFERENCE_COUNTING */
+#else /* DUK_USE_REFERENCE_COUNTING */
 
-#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv)     0
-#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h)   0
+#define DUK_TVAL_NEEDS_REFCOUNT_UPDATE(tv)   0
+#define DUK_HEAPHDR_NEEDS_REFCOUNT_UPDATE(h) 0
 
-#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_DECREF_NORZ_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_DECREF_NORZ_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_TVAL_DECREF_NORZ(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_DECREF_NORZ_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_DECREF_NORZ_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_HEAPHDR_DECREF_NORZ(thr,h)         do {} while (0) /* nop */
-#define DUK_HSTRING_INCREF_FAST(thr,h)         do {} while (0) /* nop */
-#define DUK_HSTRING_DECREF_FAST(thr,h)         do {} while (0) /* nop */
-#define DUK_HSTRING_DECREF_NORZ_FAST(thr,h)    do {} while (0) /* nop */
-#define DUK_HSTRING_INCREF_SLOW(thr,h)         do {} while (0) /* nop */
-#define DUK_HSTRING_DECREF_SLOW(thr,h)         do {} while (0) /* nop */
-#define DUK_HSTRING_DECREF_NORZ_SLOW(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_HSTRING_DECREF_NORZ(thr,h)         do {} while (0) /* nop */
-#define DUK_HOBJECT_INCREF_FAST(thr,h)         do {} while (0) /* nop */
-#define DUK_HOBJECT_DECREF_FAST(thr,h)         do {} while (0) /* nop */
-#define DUK_HOBJECT_DECREF_NORZ_FAST(thr,h)    do {} while (0) /* nop */
-#define DUK_HOBJECT_INCREF_SLOW(thr,h)         do {} while (0) /* nop */
-#define DUK_HOBJECT_DECREF_SLOW(thr,h)         do {} while (0) /* nop */
-#define DUK_HOBJECT_DECREF_NORZ_SLOW(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_HOBJECT_DECREF_NORZ(thr,h)         do {} while (0) /* nop */
-#define DUK_HBUFFER_INCREF_FAST(thr,h)         do {} while (0) /* nop */
-#define DUK_HBUFFER_DECREF_FAST(thr,h)         do {} while (0) /* nop */
-#define DUK_HBUFFER_DECREF_NORZ_FAST(thr,h)    do {} while (0) /* nop */
-#define DUK_HBUFFER_INCREF_SLOW(thr,h)         do {} while (0) /* nop */
-#define DUK_HBUFFER_DECREF_SLOW(thr,h)         do {} while (0) /* nop */
-#define DUK_HBUFFER_DECREF_NORZ_SLOW(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_HBUFFER_DECREF_NORZ(thr,h)         do {} while (0) /* nop */
+#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_DECREF_NORZ_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_DECREF_NORZ_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_TVAL_DECREF_NORZ(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_DECREF_NORZ_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_DECREF_NORZ_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_HEAPHDR_DECREF_NORZ(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HSTRING_INCREF_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HSTRING_DECREF_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HSTRING_DECREF_NORZ_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HSTRING_INCREF_SLOW(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HSTRING_DECREF_SLOW(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HSTRING_DECREF_NORZ_SLOW(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_HSTRING_DECREF_NORZ(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HOBJECT_INCREF_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HOBJECT_DECREF_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HOBJECT_DECREF_NORZ_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HOBJECT_INCREF_SLOW(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HOBJECT_DECREF_SLOW(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HOBJECT_DECREF_NORZ_SLOW(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_HOBJECT_DECREF_NORZ(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_INCREF_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_DECREF_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_DECREF_NORZ_FAST(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_INCREF_SLOW(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_DECREF_SLOW(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_DECREF_NORZ_SLOW(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_HBUFFER_DECREF_NORZ(thr, h) \
+	do { \
+	} while (0) /* nop */
 
-#define DUK_HCOMPFUNC_INCREF(thr,h)            do {} while (0) /* nop */
-#define DUK_HCOMPFUNC_DECREF(thr,h)            do {} while (0) /* nop */
-#define DUK_HCOMPFUNC_DECREF_NORZ(thr,h)       do {} while (0) /* nop */
-#define DUK_HNATFUNC_INCREF(thr,h)             do {} while (0) /* nop */
-#define DUK_HNATFUNC_DECREF(thr,h)             do {} while (0) /* nop */
-#define DUK_HNATFUNC_DECREF_NORZ(thr,h)        do {} while (0) /* nop */
-#define DUK_HBUFOBJ_INCREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HBUFOBJ_DECREF(thr,h)              do {} while (0) /* nop */
-#define DUK_HBUFOBJ_DECREF_NORZ(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_HTHREAD_DECREF_NORZ(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 */
-#define DUK_HOBJECT_DECREF_NORZ_ALLOWNULL(thr,h)  do {} while (0) /* nop */
-#define DUK_HBUFFER_INCREF_ALLOWNULL(thr,h)    do {} while (0) /* nop */
-#define DUK_HBUFFER_DECREF_ALLOWNULL(thr,h)    do {} while (0) /* nop */
-#define DUK_HBUFFER_DECREF_NORZ_ALLOWNULL(thr,h)  do {} while (0) /* nop */
+#define DUK_HCOMPFUNC_INCREF(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HCOMPFUNC_DECREF(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HCOMPFUNC_DECREF_NORZ(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HNATFUNC_INCREF(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HNATFUNC_DECREF(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HNATFUNC_DECREF_NORZ(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFOBJ_INCREF(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFOBJ_DECREF(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFOBJ_DECREF_NORZ(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_HTHREAD_DECREF_NORZ(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 */
+#define DUK_HOBJECT_DECREF_NORZ_ALLOWNULL(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_INCREF_ALLOWNULL(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_DECREF_ALLOWNULL(thr, h) \
+	do { \
+	} while (0) /* nop */
+#define DUK_HBUFFER_DECREF_NORZ_ALLOWNULL(thr, h) \
+	do { \
+	} while (0) /* nop */
 
-#define DUK_REFZERO_CHECK_FAST(thr)            do {} while (0) /* nop */
-#define DUK_REFZERO_CHECK_SLOW(thr)            do {} while (0) /* nop */
+#define DUK_REFZERO_CHECK_FAST(thr) \
+	do { \
+	} while (0) /* nop */
+#define DUK_REFZERO_CHECK_SLOW(thr) \
+	do { \
+	} while (0) /* nop */
 
-#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_UNDEFINED(tv__dst); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_UNUSED_UPDREF_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_UNUSED(tv__dst); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_NULL_UPDREF_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_NULL(tv__dst); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_BOOLEAN(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_NUMBER_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_NUMBER(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
-#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_NUMBER_CHKFAST_FAST(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
-#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_DOUBLE_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_DOUBLE(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
-#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr,tvptr_dst) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_NAN_UPDREF_ALT0(thr, tvptr_dst) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_NAN(tv__dst); \
 		DUK_UNREF((thr)); \
 	} while (0)
 #if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_I48_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_I48_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_I48(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
-#define DUK_TVAL_SET_I32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_I32_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_I32(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
-#define DUK_TVAL_SET_U32_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_U32_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_U32(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
 #else
-#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr,tvptr_dst,newval) \
+#define DUK_TVAL_SET_DOUBLE_CAST_UPDREF(thr, tvptr_dst, newval) \
 	DUK_TVAL_SET_DOUBLE_UPDREF((thr), (tvptr_dst), (duk_double_t) (newval))
-#endif  /* DUK_USE_FASTINT */
+#endif /* DUK_USE_FASTINT */
 
-#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr,tvptr_dst,lf_v,lf_fp,lf_flags) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0(thr, tvptr_dst, lf_v, lf_fp, lf_flags) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_LIGHTFUNC(tv__dst, (lf_v), (lf_fp), (lf_flags)); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_STRING_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_STRING(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_OBJECT_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_OBJECT(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_BUFFER_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_BUFFER(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr,tvptr_dst,newval) do { \
-		duk_tval *tv__dst; tv__dst = (tvptr_dst); \
+#define DUK_TVAL_SET_POINTER_UPDREF_ALT0(thr, tvptr_dst, newval) \
+	do { \
+		duk_tval *tv__dst; \
+		tv__dst = (tvptr_dst); \
 		DUK_TVAL_SET_POINTER(tv__dst, (newval)); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr,tvptr_dst,tvptr_src) do { \
+#define DUK_TVAL_SET_TVAL_UPDREF_ALT0(thr, tvptr_dst, tvptr_src) \
+	do { \
 		duk_tval *tv__dst, *tv__src; \
-		tv__dst = (tvptr_dst); tv__src = (tvptr_src); \
+		tv__dst = (tvptr_dst); \
+		tv__src = (tvptr_src); \
 		DUK_TVAL_SET_TVAL(tv__dst, tv__src); \
 		DUK_UNREF((thr)); \
 	} while (0)
 
-#define DUK_TVAL_SET_UNDEFINED_UPDREF         DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
-#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ    DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
-#define DUK_TVAL_SET_UNUSED_UPDREF            DUK_TVAL_SET_UNUSED_UPDREF_ALT0
-#define DUK_TVAL_SET_NULL_UPDREF              DUK_TVAL_SET_NULL_UPDREF_ALT0
-#define DUK_TVAL_SET_BOOLEAN_UPDREF           DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
-#define DUK_TVAL_SET_NUMBER_UPDREF            DUK_TVAL_SET_NUMBER_UPDREF_ALT0
-#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF    DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
-#define DUK_TVAL_SET_DOUBLE_UPDREF            DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
-#define DUK_TVAL_SET_NAN_UPDREF               DUK_TVAL_SET_NAN_UPDREF_ALT0
+#define DUK_TVAL_SET_UNDEFINED_UPDREF      DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
+#define DUK_TVAL_SET_UNDEFINED_UPDREF_NORZ DUK_TVAL_SET_UNDEFINED_UPDREF_ALT0
+#define DUK_TVAL_SET_UNUSED_UPDREF         DUK_TVAL_SET_UNUSED_UPDREF_ALT0
+#define DUK_TVAL_SET_NULL_UPDREF           DUK_TVAL_SET_NULL_UPDREF_ALT0
+#define DUK_TVAL_SET_BOOLEAN_UPDREF        DUK_TVAL_SET_BOOLEAN_UPDREF_ALT0
+#define DUK_TVAL_SET_NUMBER_UPDREF         DUK_TVAL_SET_NUMBER_UPDREF_ALT0
+#define DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF DUK_TVAL_SET_NUMBER_CHKFAST_UPDREF_ALT0
+#define DUK_TVAL_SET_DOUBLE_UPDREF         DUK_TVAL_SET_DOUBLE_UPDREF_ALT0
+#define DUK_TVAL_SET_NAN_UPDREF            DUK_TVAL_SET_NAN_UPDREF_ALT0
 #if defined(DUK_USE_FASTINT)
-#define DUK_TVAL_SET_I48_UPDREF               DUK_TVAL_SET_I48_UPDREF_ALT0
-#define DUK_TVAL_SET_I32_UPDREF               DUK_TVAL_SET_I32_UPDREF_ALT0
-#define DUK_TVAL_SET_U32_UPDREF               DUK_TVAL_SET_U32_UPDREF_ALT0
+#define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_I48_UPDREF_ALT0
+#define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_I32_UPDREF_ALT0
+#define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_U32_UPDREF_ALT0
 #else
-#define DUK_TVAL_SET_I48_UPDREF               DUK_TVAL_SET_DOUBLE_CAST_UPDREF  /* XXX: fast-int-to-double */
-#define DUK_TVAL_SET_I32_UPDREF               DUK_TVAL_SET_DOUBLE_CAST_UPDREF
-#define DUK_TVAL_SET_U32_UPDREF               DUK_TVAL_SET_DOUBLE_CAST_UPDREF
-#endif  /* DUK_USE_FASTINT */
-#define DUK_TVAL_SET_FASTINT_UPDREF           DUK_TVAL_SET_I48_UPDREF  /* convenience */
-#define DUK_TVAL_SET_LIGHTFUNC_UPDREF         DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
-#define DUK_TVAL_SET_STRING_UPDREF            DUK_TVAL_SET_STRING_UPDREF_ALT0
-#define DUK_TVAL_SET_OBJECT_UPDREF            DUK_TVAL_SET_OBJECT_UPDREF_ALT0
-#define DUK_TVAL_SET_BUFFER_UPDREF            DUK_TVAL_SET_BUFFER_UPDREF_ALT0
-#define DUK_TVAL_SET_POINTER_UPDREF           DUK_TVAL_SET_POINTER_UPDREF_ALT0
+#define DUK_TVAL_SET_I48_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF /* XXX: fast-int-to-double */
+#define DUK_TVAL_SET_I32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF
+#define DUK_TVAL_SET_U32_UPDREF DUK_TVAL_SET_DOUBLE_CAST_UPDREF
+#endif /* DUK_USE_FASTINT */
+#define DUK_TVAL_SET_FASTINT_UPDREF   DUK_TVAL_SET_I48_UPDREF /* convenience */
+#define DUK_TVAL_SET_LIGHTFUNC_UPDREF DUK_TVAL_SET_LIGHTFUNC_UPDREF_ALT0
+#define DUK_TVAL_SET_STRING_UPDREF    DUK_TVAL_SET_STRING_UPDREF_ALT0
+#define DUK_TVAL_SET_OBJECT_UPDREF    DUK_TVAL_SET_OBJECT_UPDREF_ALT0
+#define DUK_TVAL_SET_BUFFER_UPDREF    DUK_TVAL_SET_BUFFER_UPDREF_ALT0
+#define DUK_TVAL_SET_POINTER_UPDREF   DUK_TVAL_SET_POINTER_UPDREF_ALT0
 
-#define DUK_TVAL_SET_TVAL_UPDREF              DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#define DUK_TVAL_SET_TVAL_UPDREF_FAST         DUK_TVAL_SET_TVAL_UPDREF_ALT0
-#define DUK_TVAL_SET_TVAL_UPDREF_SLOW         DUK_TVAL_SET_TVAL_UPDREF_ALT0
+#define DUK_TVAL_SET_TVAL_UPDREF      DUK_TVAL_SET_TVAL_UPDREF_ALT0
+#define DUK_TVAL_SET_TVAL_UPDREF_FAST DUK_TVAL_SET_TVAL_UPDREF_ALT0
+#define DUK_TVAL_SET_TVAL_UPDREF_SLOW DUK_TVAL_SET_TVAL_UPDREF_ALT0
 
-#endif  /* DUK_USE_REFERENCE_COUNTING */
+#endif /* DUK_USE_REFERENCE_COUNTING */
 
 /*
  *  Some convenience macros that don't have optimized implementations now.
  */
 
-#define DUK_TVAL_SET_TVAL_UPDREF_NORZ(thr,tv_dst,tv_src) do { \
+#define DUK_TVAL_SET_TVAL_UPDREF_NORZ(thr, tv_dst, tv_src) \
+	do { \
 		duk_hthread *duk__thr = (thr); \
 		duk_tval *duk__dst = (tv_dst); \
 		duk_tval *duk__src = (tv_src); \
@@ -5448,7 +5854,8 @@
 		DUK_TVAL_INCREF(thr, duk__dst); \
 	} while (0)
 
-#define DUK_TVAL_SET_U32_UPDREF_NORZ(thr,tv_dst,val) do { \
+#define DUK_TVAL_SET_U32_UPDREF_NORZ(thr, tv_dst, val) \
+	do { \
 		duk_hthread *duk__thr = (thr); \
 		duk_tval *duk__dst = (tv_dst); \
 		duk_uint32_t duk__val = (duk_uint32_t) (val); \
@@ -5468,7 +5875,7 @@
 #endif
 DUK_INTERNAL_DECL void duk_heaphdr_refcount_finalize_norz(duk_heap *heap, duk_heaphdr *hdr);
 DUK_INTERNAL_DECL void duk_hobject_refcount_finalize_norz(duk_heap *heap, duk_hobject *h);
-#if 0  /* Not needed: fast path handles inline; slow path uses duk_heaphdr_decref() which is needed anyway. */
+#if 0 /* Not needed: fast path handles inline; slow path uses duk_heaphdr_decref() which is needed anyway. */
 DUK_INTERNAL_DECL void duk_hstring_decref(duk_hthread *thr, duk_hstring *h);
 DUK_INTERNAL_DECL void duk_hstring_decref_norz(duk_hthread *thr, duk_hstring *h);
 DUK_INTERNAL_DECL void duk_hbuffer_decref(duk_hthread *thr, duk_hbuffer *h);
@@ -5479,8 +5886,8 @@
 DUK_INTERNAL_DECL void duk_heaphdr_refzero(duk_hthread *thr, duk_heaphdr *h);
 DUK_INTERNAL_DECL void duk_heaphdr_refzero_norz(duk_hthread *thr, duk_heaphdr *h);
 #if defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
-DUK_INTERNAL_DECL void duk_hstring_refzero(duk_hthread *thr, duk_hstring *h);  /* no 'norz' variant */
-DUK_INTERNAL_DECL void duk_hbuffer_refzero(duk_hthread *thr, duk_hbuffer *h);  /* no 'norz' variant */
+DUK_INTERNAL_DECL void duk_hstring_refzero(duk_hthread *thr, duk_hstring *h); /* no 'norz' variant */
+DUK_INTERNAL_DECL void duk_hbuffer_refzero(duk_hthread *thr, duk_hbuffer *h); /* no 'norz' variant */
 DUK_INTERNAL_DECL void duk_hobject_refzero(duk_hthread *thr, duk_hobject *h);
 DUK_INTERNAL_DECL void duk_hobject_refzero_norz(duk_hthread *thr, duk_hobject *h);
 #else
@@ -5491,11 +5898,11 @@
 DUK_INTERNAL_DECL void duk_heaphdr_decref(duk_hthread *thr, duk_heaphdr *h);
 DUK_INTERNAL_DECL void duk_heaphdr_decref_norz(duk_hthread *thr, duk_heaphdr *h);
 #endif
-#else  /* DUK_USE_REFERENCE_COUNTING */
+#else /* DUK_USE_REFERENCE_COUNTING */
 /* no refcounting */
-#endif  /* DUK_USE_REFERENCE_COUNTING */
+#endif /* DUK_USE_REFERENCE_COUNTING */
 
-#endif  /* DUK_REFCOUNT_H_INCLUDED */
+#endif /* DUK_REFCOUNT_H_INCLUDED */
 /* #include duk_api_internal.h */
 #line 1 "duk_api_internal.h"
 /*
@@ -5512,9 +5919,9 @@
 #define DUK_ALWAYS_INLINE_PERF
 #define DUK_NOINLINE_PERF
 #else
-#define DUK_INLINE_PERF DUK_INLINE
+#define DUK_INLINE_PERF        DUK_INLINE
 #define DUK_ALWAYS_INLINE_PERF DUK_ALWAYS_INLINE
-#define DUK_NOINLINE_PERF DUK_NOINLINE
+#define DUK_NOINLINE_PERF      DUK_NOINLINE
 #endif
 
 /* Inline macro helpers, for bytecode executor. */
@@ -5523,19 +5930,19 @@
 #define DUK_EXEC_ALWAYS_INLINE_PERF
 #define DUK_EXEC_NOINLINE_PERF
 #else
-#define DUK_EXEC_INLINE_PERF DUK_INLINE
+#define DUK_EXEC_INLINE_PERF        DUK_INLINE
 #define DUK_EXEC_ALWAYS_INLINE_PERF DUK_ALWAYS_INLINE
-#define DUK_EXEC_NOINLINE_PERF DUK_NOINLINE
+#define DUK_EXEC_NOINLINE_PERF      DUK_NOINLINE
 #endif
 
 /* duk_push_sprintf constants */
-#define DUK_PUSH_SPRINTF_INITIAL_SIZE  256L
-#define DUK_PUSH_SPRINTF_SANITY_LIMIT  (1L * 1024L * 1024L * 1024L)
+#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)
+#define DUK_ERRCODE_FLAG_NOBLAME_FILELINE (1L << 24)
 
 /* Current convention is to use duk_size_t for value stack sizes and global indices,
  * and duk_idx_t for local frame indices.
@@ -5597,24 +6004,17 @@
 DUK_INTERNAL_DECL duk_tval *duk_get_borrowed_this_tval(duk_hthread *thr);
 
 /* XXX: add fastint support? */
-#define duk_push_u64(thr,val) \
-	duk_push_number((thr), (duk_double_t) (val))
-#define duk_push_i64(thr,val) \
-	duk_push_number((thr), (duk_double_t) (val))
+#define duk_push_u64(thr, val) duk_push_number((thr), (duk_double_t) (val))
+#define duk_push_i64(thr, val) duk_push_number((thr), (duk_double_t) (val))
 
 /* duk_push_(u)int() is guaranteed to support at least (un)signed 32-bit range */
-#define duk_push_u32(thr,val) \
-	duk_push_uint((thr), (duk_uint_t) (val))
-#define duk_push_i32(thr,val) \
-	duk_push_int((thr), (duk_int_t) (val))
+#define duk_push_u32(thr, val) duk_push_uint((thr), (duk_uint_t) (val))
+#define duk_push_i32(thr, val) duk_push_int((thr), (duk_int_t) (val))
 
 /* sometimes stack and array indices need to go on the stack */
-#define duk_push_idx(thr,val) \
-	duk_push_int((thr), (duk_int_t) (val))
-#define duk_push_uarridx(thr,val) \
-	duk_push_uint((thr), (duk_uint_t) (val))
-#define duk_push_size_t(thr,val) \
-	duk_push_uint((thr), (duk_uint_t) (val))  /* XXX: assumed to fit for now */
+#define duk_push_idx(thr, val)     duk_push_int((thr), (duk_int_t) (val))
+#define duk_push_uarridx(thr, val) duk_push_uint((thr), (duk_uint_t) (val))
+#define duk_push_size_t(thr, val)  duk_push_uint((thr), (duk_uint_t) (val)) /* XXX: assumed to fit for now */
 
 DUK_INTERNAL_DECL duk_bool_t duk_is_string_notsymbol(duk_hthread *thr, duk_idx_t idx);
 
@@ -5631,19 +6031,23 @@
 DUK_INTERNAL_DECL duk_hcompfunc *duk_get_hcompfunc(duk_hthread *thr, duk_idx_t idx);
 DUK_INTERNAL_DECL duk_hnatfunc *duk_get_hnatfunc(duk_hthread *thr, duk_idx_t idx);
 
-DUK_INTERNAL_DECL void *duk_get_buffer_data_raw(duk_hthread *thr, duk_idx_t idx, duk_size_t *out_size, void *def_ptr, duk_size_t def_len, duk_bool_t throw_flag, duk_bool_t *out_isbuffer);
+DUK_INTERNAL_DECL void *duk_get_buffer_data_raw(duk_hthread *thr,
+                                                duk_idx_t idx,
+                                                duk_size_t *out_size,
+                                                void *def_ptr,
+                                                duk_size_t def_len,
+                                                duk_bool_t throw_flag,
+                                                duk_bool_t *out_isbuffer);
 
 DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_with_class(duk_hthread *thr, duk_idx_t idx, duk_small_uint_t classnum);
 
 DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_promote_mask(duk_hthread *thr, duk_idx_t idx, duk_uint_t type_mask);
 DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_promote_mask(duk_hthread *thr, duk_idx_t idx, duk_uint_t type_mask);
 DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_accept_mask(duk_hthread *thr, duk_idx_t idx, duk_uint_t type_mask);
-#define duk_require_hobject_promote_lfunc(thr,idx) \
-	duk_require_hobject_promote_mask((thr), (idx), DUK_TYPE_MASK_LIGHTFUNC)
-#define duk_get_hobject_promote_lfunc(thr,idx) \
-	duk_get_hobject_promote_mask((thr), (idx), DUK_TYPE_MASK_LIGHTFUNC)
+#define duk_require_hobject_promote_lfunc(thr, idx) duk_require_hobject_promote_mask((thr), (idx), DUK_TYPE_MASK_LIGHTFUNC)
+#define duk_get_hobject_promote_lfunc(thr, idx)     duk_get_hobject_promote_mask((thr), (idx), DUK_TYPE_MASK_LIGHTFUNC)
 
-#if 0  /*unused*/
+#if 0 /*unused*/
 DUK_INTERNAL_DECL void *duk_get_voidptr(duk_hthread *thr, duk_idx_t idx);
 #endif
 
@@ -5666,12 +6070,16 @@
 
 DUK_INTERNAL_DECL duk_bool_t duk_to_boolean_top_pop(duk_hthread *thr);
 
-#if defined(DUK_USE_DEBUGGER_SUPPORT)  /* only needed by debugger for now */
+#if defined(DUK_USE_DEBUGGER_SUPPORT) /* only needed by debugger for now */
 DUK_INTERNAL_DECL duk_hstring *duk_safe_to_hstring(duk_hthread *thr, duk_idx_t idx);
 #endif
 DUK_INTERNAL_DECL void duk_push_class_string_tval(duk_hthread *thr, duk_tval *tv, duk_bool_t avoid_side_effects);
 
-DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped_raw(duk_hthread *thr, duk_idx_t idx, 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_raw(duk_hthread *thr,
+                                                   duk_idx_t idx,
+                                                   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_hthread *thr, duk_idx_t idx, duk_int_t minval, duk_int_t maxval);
 DUK_INTERNAL_DECL duk_int_t duk_to_int_check_range(duk_hthread *thr, duk_idx_t idx, duk_int_t minval, duk_int_t maxval);
 #if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
@@ -5696,13 +6104,15 @@
 DUK_INTERNAL_DECL void duk_push_hstring_empty(duk_hthread *thr);
 DUK_INTERNAL_DECL void duk_push_hobject(duk_hthread *thr, duk_hobject *h);
 DUK_INTERNAL_DECL void duk_push_hbuffer(duk_hthread *thr, duk_hbuffer *h);
-#define duk_push_hthread(thr,h) \
-	duk_push_hobject((thr), (duk_hobject *) (h))
-#define duk_push_hnatfunc(thr,h) \
-	duk_push_hobject((thr), (duk_hobject *) (h))
+#define duk_push_hthread(thr, h)  duk_push_hobject((thr), (duk_hobject *) (h))
+#define duk_push_hnatfunc(thr, h) duk_push_hobject((thr), (duk_hobject *) (h))
 DUK_INTERNAL_DECL void duk_push_hobject_bidx(duk_hthread *thr, duk_small_int_t builtin_idx);
-DUK_INTERNAL_DECL duk_hobject *duk_push_object_helper(duk_hthread *thr, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx);
-DUK_INTERNAL_DECL duk_hobject *duk_push_object_helper_proto(duk_hthread *thr, duk_uint_t hobject_flags_and_class, duk_hobject *proto);
+DUK_INTERNAL_DECL duk_hobject *duk_push_object_helper(duk_hthread *thr,
+                                                      duk_uint_t hobject_flags_and_class,
+                                                      duk_small_int_t prototype_bidx);
+DUK_INTERNAL_DECL duk_hobject *duk_push_object_helper_proto(duk_hthread *thr,
+                                                            duk_uint_t hobject_flags_and_class,
+                                                            duk_hobject *proto);
 DUK_INTERNAL_DECL duk_hcompfunc *duk_push_hcompfunc(duk_hthread *thr);
 DUK_INTERNAL_DECL duk_hboundfunc *duk_push_hboundfunc(duk_hthread *thr);
 DUK_INTERNAL_DECL void duk_push_c_function_builtin(duk_hthread *thr, duk_c_function func, duk_int_t nargs);
@@ -5719,11 +6129,13 @@
 DUK_INTERNAL_DECL void duk_push_lightfunc_name_raw(duk_hthread *thr, duk_c_function func, duk_small_uint_t lf_flags);
 DUK_INTERNAL_DECL void duk_push_lightfunc_name(duk_hthread *thr, duk_tval *tv);
 DUK_INTERNAL_DECL void duk_push_lightfunc_tostring(duk_hthread *thr, duk_tval *tv);
-#if 0  /* not used yet */
+#if 0 /* not used yet */
 DUK_INTERNAL_DECL void duk_push_hnatfunc_name(duk_hthread *thr, duk_hnatfunc *h);
 #endif
 #if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
-DUK_INTERNAL_DECL duk_hbufobj *duk_push_bufobj_raw(duk_hthread *thr, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx);
+DUK_INTERNAL_DECL duk_hbufobj *duk_push_bufobj_raw(duk_hthread *thr,
+                                                   duk_uint_t hobject_flags_and_class,
+                                                   duk_small_int_t prototype_bidx);
 #endif
 
 DUK_INTERNAL_DECL void *duk_push_fixed_buffer_nozero(duk_hthread *thr, duk_size_t len);
@@ -5740,80 +6152,86 @@
  * arguments and such call sites are also easiest to verify to be correct.
  */
 
-DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx);     /* [] -> [val] */
+DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx); /* [] -> [val] */
 DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx_short_raw(duk_hthread *thr, duk_uint_t packed_args);
-#define duk_get_prop_stridx_short(thr,obj_idx,stridx) \
+#define duk_get_prop_stridx_short(thr, obj_idx, stridx) \
 	(DUK_ASSERT_EXPR((duk_int_t) (obj_idx) >= -0x8000L && (duk_int_t) (obj_idx) <= 0x7fffL), \
 	 DUK_ASSERT_EXPR((duk_int_t) (stridx) >= 0 && (duk_int_t) (stridx) <= 0xffffL), \
 	 duk_get_prop_stridx_short_raw((thr), (((duk_uint_t) (obj_idx)) << 16) + ((duk_uint_t) (stridx))))
-DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx_boolean(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx, duk_bool_t *out_has_prop);  /* [] -> [] */
+DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx_boolean(duk_hthread *thr,
+                                                         duk_idx_t obj_idx,
+                                                         duk_small_uint_t stridx,
+                                                         duk_bool_t *out_has_prop); /* [] -> [] */
 
 DUK_INTERNAL_DECL duk_bool_t duk_xget_owndataprop(duk_hthread *thr, duk_idx_t obj_idx);
 DUK_INTERNAL_DECL duk_bool_t duk_xget_owndataprop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx);
 DUK_INTERNAL_DECL duk_bool_t duk_xget_owndataprop_stridx_short_raw(duk_hthread *thr, duk_uint_t packed_args);
-#define duk_xget_owndataprop_stridx_short(thr,obj_idx,stridx) \
+#define duk_xget_owndataprop_stridx_short(thr, obj_idx, stridx) \
 	(DUK_ASSERT_EXPR((duk_int_t) (obj_idx) >= -0x8000L && (duk_int_t) (obj_idx) <= 0x7fffL), \
 	 DUK_ASSERT_EXPR((duk_int_t) (stridx) >= 0 && (duk_int_t) (stridx) <= 0xffffL), \
 	 duk_xget_owndataprop_stridx_short_raw((thr), (((duk_uint_t) (obj_idx)) << 16) + ((duk_uint_t) (stridx))))
 
-DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx);     /* [val] -> [] */
+DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx); /* [val] -> [] */
 DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx_short_raw(duk_hthread *thr, duk_uint_t packed_args);
-#define duk_put_prop_stridx_short(thr,obj_idx,stridx) \
+#define duk_put_prop_stridx_short(thr, obj_idx, stridx) \
 	(DUK_ASSERT_EXPR((duk_int_t) (obj_idx) >= -0x8000L && (duk_int_t) (obj_idx) <= 0x7fffL), \
 	 DUK_ASSERT_EXPR((duk_int_t) (stridx) >= 0 && (duk_int_t) (stridx) <= 0xffffL), \
 	 duk_put_prop_stridx_short_raw((thr), (((duk_uint_t) (obj_idx)) << 16) + ((duk_uint_t) (stridx))))
 
-DUK_INTERNAL_DECL duk_bool_t duk_del_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx);     /* [] -> [] */
-#if 0  /* Too few call sites to be useful. */
+DUK_INTERNAL_DECL duk_bool_t duk_del_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx); /* [] -> [] */
+#if 0 /* Too few call sites to be useful. */
 DUK_INTERNAL_DECL duk_bool_t duk_del_prop_stridx_short_raw(duk_hthread *thr, duk_uint_t packed_args);
-#define duk_del_prop_stridx_short(thr,obj_idx,stridx) \
+#define duk_del_prop_stridx_short(thr, obj_idx, stridx) \
 	(DUK_ASSERT_EXPR((obj_idx) >= -0x8000L && (obj_idx) <= 0x7fffL), \
 	 DUK_ASSERT_EXPR((stridx) >= 0 && (stridx) <= 0xffffL), \
 	 duk_del_prop_stridx_short_raw((thr), (((duk_uint_t) (obj_idx)) << 16) + ((duk_uint_t) (stridx))))
 #endif
-#define duk_del_prop_stridx_short(thr,obj_idx,stridx) \
-	duk_del_prop_stridx((thr), (obj_idx), (stridx))
+#define duk_del_prop_stridx_short(thr, obj_idx, stridx) duk_del_prop_stridx((thr), (obj_idx), (stridx))
 
-DUK_INTERNAL_DECL duk_bool_t duk_has_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx);     /* [] -> [] */
-#if 0  /* Too few call sites to be useful. */
+DUK_INTERNAL_DECL duk_bool_t duk_has_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx); /* [] -> [] */
+#if 0 /* Too few call sites to be useful. */
 DUK_INTERNAL_DECL duk_bool_t duk_has_prop_stridx_short_raw(duk_hthread *thr, duk_uint_t packed_args);
-#define duk_has_prop_stridx_short(thr,obj_idx,stridx) \
+#define duk_has_prop_stridx_short(thr, obj_idx, stridx) \
 	(DUK_ASSERT_EXPR((obj_idx) >= -0x8000L && (obj_idx) <= 0x7fffL), \
 	 DUK_ASSERT_EXPR((stridx) >= 0 && (stridx) <= 0xffffL), \
 	 duk_has_prop_stridx_short_raw((thr), (((duk_uint_t) (obj_idx)) << 16) + ((duk_uint_t) (stridx))))
 #endif
-#define duk_has_prop_stridx_short(thr,obj_idx,stridx) \
-	duk_has_prop_stridx((thr), (obj_idx), (stridx))
+#define duk_has_prop_stridx_short(thr, obj_idx, stridx) duk_has_prop_stridx((thr), (obj_idx), (stridx))
 
-DUK_INTERNAL_DECL void duk_xdef_prop(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t desc_flags);  /* [key val] -> [] */
+DUK_INTERNAL_DECL void duk_xdef_prop(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t desc_flags); /* [key val] -> [] */
 
-DUK_INTERNAL_DECL void duk_xdef_prop_index(duk_hthread *thr, duk_idx_t obj_idx, duk_uarridx_t arr_idx, duk_small_uint_t desc_flags);  /* [val] -> [] */
+DUK_INTERNAL_DECL void duk_xdef_prop_index(duk_hthread *thr,
+                                           duk_idx_t obj_idx,
+                                           duk_uarridx_t arr_idx,
+                                           duk_small_uint_t desc_flags); /* [val] -> [] */
 
 /* XXX: Because stridx and desc_flags have a limited range, this call could
  * always pack stridx and desc_flags into a single argument.
  */
-DUK_INTERNAL_DECL void duk_xdef_prop_stridx(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx, duk_small_uint_t desc_flags);  /* [val] -> [] */
+DUK_INTERNAL_DECL void duk_xdef_prop_stridx(duk_hthread *thr,
+                                            duk_idx_t obj_idx,
+                                            duk_small_uint_t stridx,
+                                            duk_small_uint_t desc_flags); /* [val] -> [] */
 DUK_INTERNAL_DECL void duk_xdef_prop_stridx_short_raw(duk_hthread *thr, duk_uint_t packed_args);
-#define duk_xdef_prop_stridx_short(thr,obj_idx,stridx,desc_flags) \
+#define duk_xdef_prop_stridx_short(thr, obj_idx, stridx, desc_flags) \
 	(DUK_ASSERT_EXPR((duk_int_t) (obj_idx) >= -0x80L && (duk_int_t) (obj_idx) <= 0x7fL), \
 	 DUK_ASSERT_EXPR((duk_int_t) (stridx) >= 0 && (duk_int_t) (stridx) <= 0xffffL), \
 	 DUK_ASSERT_EXPR((duk_int_t) (desc_flags) >= 0 && (duk_int_t) (desc_flags) <= 0xffL), \
-	 duk_xdef_prop_stridx_short_raw((thr), (((duk_uint_t) (obj_idx)) << 24) + (((duk_uint_t) (stridx)) << 8) + (duk_uint_t) (desc_flags)))
+	 duk_xdef_prop_stridx_short_raw((thr), \
+	                                (((duk_uint_t) (obj_idx)) << 24) + (((duk_uint_t) (stridx)) << 8) + \
+	                                    (duk_uint_t) (desc_flags)))
 
-#define duk_xdef_prop_wec(thr,obj_idx) \
-	duk_xdef_prop((thr), (obj_idx), DUK_PROPDESC_FLAGS_WEC)
-#define duk_xdef_prop_index_wec(thr,obj_idx,arr_idx) \
-	duk_xdef_prop_index((thr), (obj_idx), (arr_idx), DUK_PROPDESC_FLAGS_WEC)
-#define duk_xdef_prop_stridx_wec(thr,obj_idx,stridx) \
-	duk_xdef_prop_stridx((thr), (obj_idx), (stridx), DUK_PROPDESC_FLAGS_WEC)
-#define duk_xdef_prop_stridx_short_wec(thr,obj_idx,stridx) \
+#define duk_xdef_prop_wec(thr, obj_idx)                duk_xdef_prop((thr), (obj_idx), DUK_PROPDESC_FLAGS_WEC)
+#define duk_xdef_prop_index_wec(thr, obj_idx, arr_idx) duk_xdef_prop_index((thr), (obj_idx), (arr_idx), DUK_PROPDESC_FLAGS_WEC)
+#define duk_xdef_prop_stridx_wec(thr, obj_idx, stridx) duk_xdef_prop_stridx((thr), (obj_idx), (stridx), DUK_PROPDESC_FLAGS_WEC)
+#define duk_xdef_prop_stridx_short_wec(thr, obj_idx, stridx) \
 	duk_xdef_prop_stridx_short((thr), (obj_idx), (stridx), DUK_PROPDESC_FLAGS_WEC)
 
-#if 0  /*unused*/
+#if 0 /*unused*/
 DUK_INTERNAL_DECL void duk_xdef_prop_stridx_builtin(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx, duk_small_int_t builtin_idx, duk_small_uint_t desc_flags);  /* [] -> [] */
 #endif
 
-DUK_INTERNAL_DECL void duk_xdef_prop_stridx_thrower(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx);  /* [] -> [] */
+DUK_INTERNAL_DECL void duk_xdef_prop_stridx_thrower(duk_hthread *thr, duk_idx_t obj_idx, duk_small_uint_t stridx); /* [] -> [] */
 
 DUK_INTERNAL_DECL duk_bool_t duk_get_method_stridx(duk_hthread *thr, duk_idx_t idx, duk_small_uint_t stridx);
 
@@ -5862,28 +6280,24 @@
  * using these macro results in faster and smaller code than duk_get_tval().
  * Both 'ctx' and 'idx' are evaluted multiple times, but only for asserts.
  */
-#define DUK_ASSERT_VALID_NEGIDX(thr,idx) \
+#define DUK_ASSERT_VALID_NEGIDX(thr, idx) \
 	(DUK_ASSERT_EXPR((duk_int_t) (idx) < 0), DUK_ASSERT_EXPR(duk_is_valid_index((thr), (idx))))
-#define DUK_ASSERT_VALID_POSIDX(thr,idx) \
+#define DUK_ASSERT_VALID_POSIDX(thr, idx) \
 	(DUK_ASSERT_EXPR((duk_int_t) (idx) >= 0), DUK_ASSERT_EXPR(duk_is_valid_index((thr), (idx))))
-#define DUK_GET_TVAL_NEGIDX(thr,idx) \
-	(DUK_ASSERT_VALID_NEGIDX((thr),(idx)), ((duk_hthread *) (thr))->valstack_top + (idx))
-#define DUK_GET_TVAL_POSIDX(thr,idx) \
-	(DUK_ASSERT_VALID_POSIDX((thr),(idx)), ((duk_hthread *) (thr))->valstack_bottom + (idx))
-#define DUK_GET_HOBJECT_NEGIDX(thr,idx) \
-	(DUK_ASSERT_VALID_NEGIDX((thr),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (thr))->valstack_top + (idx)))
-#define DUK_GET_HOBJECT_POSIDX(thr,idx) \
-	(DUK_ASSERT_VALID_POSIDX((thr),(idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (thr))->valstack_bottom + (idx)))
+#define DUK_GET_TVAL_NEGIDX(thr, idx) (DUK_ASSERT_VALID_NEGIDX((thr), (idx)), ((duk_hthread *) (thr))->valstack_top + (idx))
+#define DUK_GET_TVAL_POSIDX(thr, idx) (DUK_ASSERT_VALID_POSIDX((thr), (idx)), ((duk_hthread *) (thr))->valstack_bottom + (idx))
+#define DUK_GET_HOBJECT_NEGIDX(thr, idx) \
+	(DUK_ASSERT_VALID_NEGIDX((thr), (idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (thr))->valstack_top + (idx)))
+#define DUK_GET_HOBJECT_POSIDX(thr, idx) \
+	(DUK_ASSERT_VALID_POSIDX((thr), (idx)), DUK_TVAL_GET_OBJECT(((duk_hthread *) (thr))->valstack_bottom + (idx)))
 
-#define DUK_GET_THIS_TVAL_PTR(thr) \
-	(DUK_ASSERT_EXPR((thr)->valstack_bottom > (thr)->valstack), \
-	 (thr)->valstack_bottom - 1)
+#define DUK_GET_THIS_TVAL_PTR(thr) (DUK_ASSERT_EXPR((thr)->valstack_bottom > (thr)->valstack), (thr)->valstack_bottom - 1)
 
 DUK_INTERNAL_DECL duk_double_t duk_time_get_ecmascript_time(duk_hthread *thr);
 DUK_INTERNAL_DECL duk_double_t duk_time_get_ecmascript_time_nofrac(duk_hthread *thr);
 DUK_INTERNAL_DECL duk_double_t duk_time_get_monotonic_time(duk_hthread *thr);
 
-#endif  /* DUK_API_INTERNAL_H_INCLUDED */
+#endif /* DUK_API_INTERNAL_H_INCLUDED */
 /* #include duk_hstring.h */
 #line 1 "duk_hstring.h"
 /*
@@ -5915,9 +6329,9 @@
  */
 
 #if defined(DUK_USE_STRLEN16)
-#define DUK_HSTRING_MAX_BYTELEN                     (0x0000ffffUL)
+#define DUK_HSTRING_MAX_BYTELEN (0x0000ffffUL)
 #else
-#define DUK_HSTRING_MAX_BYTELEN                     (0x7fffffffUL)
+#define DUK_HSTRING_MAX_BYTELEN (0x7fffffffUL)
 #endif
 
 /* XXX: could add flags for "is valid CESU-8" (ECMAScript compatible strings),
@@ -5929,139 +6343,148 @@
 /* With lowmem builds the high 16 bits of duk_heaphdr are used for other
  * purposes, so this leaves 7 duk_heaphdr flags and 9 duk_hstring flags.
  */
-#define DUK_HSTRING_FLAG_ASCII                      DUK_HEAPHDR_USER_FLAG(0)  /* string is ASCII, clen == blen */
-#define DUK_HSTRING_FLAG_ARRIDX                     DUK_HEAPHDR_USER_FLAG(1)  /* string is a valid array index */
-#define DUK_HSTRING_FLAG_SYMBOL                     DUK_HEAPHDR_USER_FLAG(2)  /* string is a symbol (invalid utf-8) */
-#define DUK_HSTRING_FLAG_HIDDEN                     DUK_HEAPHDR_USER_FLAG(3)  /* string is a hidden symbol (implies symbol, Duktape 1.x internal string) */
-#define DUK_HSTRING_FLAG_RESERVED_WORD              DUK_HEAPHDR_USER_FLAG(4)  /* string is a reserved word (non-strict) */
-#define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD       DUK_HEAPHDR_USER_FLAG(5)  /* string is a reserved word (strict) */
-#define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS          DUK_HEAPHDR_USER_FLAG(6)  /* string is 'eval' or 'arguments' */
-#define DUK_HSTRING_FLAG_EXTDATA                    DUK_HEAPHDR_USER_FLAG(7)  /* string data is external (duk_hstring_external) */
-#define DUK_HSTRING_FLAG_PINNED_LITERAL             DUK_HEAPHDR_USER_FLAG(8)  /* string is a literal, and pinned */
+#define DUK_HSTRING_FLAG_ASCII  DUK_HEAPHDR_USER_FLAG(0) /* string is ASCII, clen == blen */
+#define DUK_HSTRING_FLAG_ARRIDX DUK_HEAPHDR_USER_FLAG(1) /* string is a valid array index */
+#define DUK_HSTRING_FLAG_SYMBOL DUK_HEAPHDR_USER_FLAG(2) /* string is a symbol (invalid utf-8) */
+#define DUK_HSTRING_FLAG_HIDDEN \
+	DUK_HEAPHDR_USER_FLAG(3) /* string is a hidden symbol (implies symbol, Duktape 1.x internal string) */
+#define DUK_HSTRING_FLAG_RESERVED_WORD        DUK_HEAPHDR_USER_FLAG(4) /* string is a reserved word (non-strict) */
+#define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD DUK_HEAPHDR_USER_FLAG(5) /* string is a reserved word (strict) */
+#define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS    DUK_HEAPHDR_USER_FLAG(6) /* string is 'eval' or 'arguments' */
+#define DUK_HSTRING_FLAG_EXTDATA              DUK_HEAPHDR_USER_FLAG(7) /* string data is external (duk_hstring_external) */
+#define DUK_HSTRING_FLAG_PINNED_LITERAL       DUK_HEAPHDR_USER_FLAG(8) /* string is a literal, and pinned */
 
-#define DUK_HSTRING_HAS_ASCII(x)                    DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
-#define DUK_HSTRING_HAS_ARRIDX(x)                   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
-#define DUK_HSTRING_HAS_SYMBOL(x)                   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
-#define DUK_HSTRING_HAS_HIDDEN(x)                   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
-#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_HAS_PINNED_LITERAL(x)           DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
+#define DUK_HSTRING_HAS_ASCII(x)                DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
+#define DUK_HSTRING_HAS_ARRIDX(x)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
+#define DUK_HSTRING_HAS_SYMBOL(x)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
+#define DUK_HSTRING_HAS_HIDDEN(x)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
+#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_HAS_PINNED_LITERAL(x)       DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
 
-#define DUK_HSTRING_SET_ASCII(x)                    DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
-#define DUK_HSTRING_SET_ARRIDX(x)                   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
-#define DUK_HSTRING_SET_SYMBOL(x)                   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
-#define DUK_HSTRING_SET_HIDDEN(x)                   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
-#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_SET_PINNED_LITERAL(x)           DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
+#define DUK_HSTRING_SET_ASCII(x)                DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
+#define DUK_HSTRING_SET_ARRIDX(x)               DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
+#define DUK_HSTRING_SET_SYMBOL(x)               DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
+#define DUK_HSTRING_SET_HIDDEN(x)               DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
+#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_SET_PINNED_LITERAL(x)       DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
 
-#define DUK_HSTRING_CLEAR_ASCII(x)                  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
-#define DUK_HSTRING_CLEAR_ARRIDX(x)                 DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
-#define DUK_HSTRING_CLEAR_SYMBOL(x)                 DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
-#define DUK_HSTRING_CLEAR_HIDDEN(x)                 DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
-#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_CLEAR_PINNED_LITERAL(x)         DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
+#define DUK_HSTRING_CLEAR_ASCII(x)                DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ASCII)
+#define DUK_HSTRING_CLEAR_ARRIDX(x)               DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
+#define DUK_HSTRING_CLEAR_SYMBOL(x)               DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_SYMBOL)
+#define DUK_HSTRING_CLEAR_HIDDEN(x)               DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_HIDDEN)
+#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_CLEAR_PINNED_LITERAL(x)       DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_PINNED_LITERAL)
 
-#if 0  /* Slightly smaller code without explicit flag, but explicit flag
-        * is very useful when 'clen' is dropped.
-        */
-#define DUK_HSTRING_IS_ASCII(x)                     (DUK_HSTRING_GET_BYTELEN((x)) == DUK_HSTRING_GET_CHARLEN((x)))
+#if 0 /* Slightly smaller code without explicit flag, but explicit flag \
+       * is very useful when 'clen' is dropped. \
+       */
+#define DUK_HSTRING_IS_ASCII(x) (DUK_HSTRING_GET_BYTELEN((x)) == DUK_HSTRING_GET_CHARLEN((x)))
 #endif
-#define DUK_HSTRING_IS_ASCII(x)                     DUK_HSTRING_HAS_ASCII((x))  /* lazily set! */
-#define DUK_HSTRING_IS_EMPTY(x)                     (DUK_HSTRING_GET_BYTELEN((x)) == 0)
+#define DUK_HSTRING_IS_ASCII(x) DUK_HSTRING_HAS_ASCII((x)) /* lazily set! */
+#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 { \
+#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 { \
+#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)->hdr.h_strextra16)
-#define DUK_HSTRING_SET_BYTELEN(x,v) do { \
+#define DUK_HSTRING_GET_BYTELEN(x) ((x)->hdr.h_strextra16)
+#define DUK_HSTRING_SET_BYTELEN(x, v) \
+	do { \
 		(x)->hdr.h_strextra16 = (v); \
 	} while (0)
 #if defined(DUK_USE_HSTRING_CLEN)
-#define DUK_HSTRING_GET_CHARLEN(x)                  duk_hstring_get_charlen((x))
-#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
+#define DUK_HSTRING_GET_CHARLEN(x) duk_hstring_get_charlen((x))
+#define DUK_HSTRING_SET_CHARLEN(x, v) \
+	do { \
 		(x)->clen16 = (v); \
 	} while (0)
 #else
-#define DUK_HSTRING_GET_CHARLEN(x)                  duk_hstring_get_charlen((x))
-#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
-		DUK_ASSERT(0);  /* should never be called */ \
+#define DUK_HSTRING_GET_CHARLEN(x) duk_hstring_get_charlen((x))
+#define DUK_HSTRING_SET_CHARLEN(x, v) \
+	do { \
+		DUK_ASSERT(0); /* should never be called */ \
 	} while (0)
 #endif
 #else
-#define DUK_HSTRING_GET_BYTELEN(x)                  ((x)->blen)
-#define DUK_HSTRING_SET_BYTELEN(x,v) do { \
+#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)                  duk_hstring_get_charlen((x))
-#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
+#define DUK_HSTRING_GET_CHARLEN(x) duk_hstring_get_charlen((x))
+#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_EXTDATA(x) ((x)->extdata)
 #define DUK_HSTRING_GET_DATA(x) \
-	(DUK_HSTRING_HAS_EXTDATA((x)) ? \
-		DUK_HSTRING_GET_EXTDATA((const duk_hstring_external *) (x)) : ((const duk_uint8_t *) ((x) + 1)))
+	(DUK_HSTRING_HAS_EXTDATA((x)) ? DUK_HSTRING_GET_EXTDATA((const duk_hstring_external *) (x)) : \
+                                        ((const duk_uint8_t *) ((x) + 1)))
 #else
-#define DUK_HSTRING_GET_DATA(x) \
-	((const duk_uint8_t *) ((x) + 1))
+#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)
+#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)
+#define DUK_HSTRING_NO_ARRAY_INDEX (0xffffffffUL)
 
 #if defined(DUK_USE_HSTRING_ARRIDX)
-#define DUK_HSTRING_GET_ARRIDX_FAST(h)  ((h)->arridx)
-#define DUK_HSTRING_GET_ARRIDX_SLOW(h)  ((h)->arridx)
+#define DUK_HSTRING_GET_ARRIDX_FAST(h) ((h)->arridx)
+#define DUK_HSTRING_GET_ARRIDX_SLOW(h) ((h)->arridx)
 #else
 /* 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)  \
+#define DUK_HSTRING_GET_ARRIDX_FAST(h) \
 	(DUK_HSTRING_HAS_ARRIDX((h)) ? duk_js_to_arrayindex_hstring_fast_known((h)) : DUK_HSTRING_NO_ARRAY_INDEX)
 
 /* Slower but more compact variant. */
-#define DUK_HSTRING_GET_ARRIDX_SLOW(h)  \
-	(duk_js_to_arrayindex_hstring_fast((h)))
+#define DUK_HSTRING_GET_ARRIDX_SLOW(h) (duk_js_to_arrayindex_hstring_fast((h)))
 #endif
 
 /* XXX: these actually fit into duk_hstring */
-#define DUK_SYMBOL_TYPE_HIDDEN 0
-#define DUK_SYMBOL_TYPE_GLOBAL 1
-#define DUK_SYMBOL_TYPE_LOCAL 2
+#define DUK_SYMBOL_TYPE_HIDDEN    0
+#define DUK_SYMBOL_TYPE_GLOBAL    1
+#define DUK_SYMBOL_TYPE_LOCAL     2
 #define DUK_SYMBOL_TYPE_WELLKNOWN 3
 
 /* Assertion for duk_hstring validity. */
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hstring_assert_valid(duk_hstring *h);
-#define DUK_HSTRING_ASSERT_VALID(h)  do { duk_hstring_assert_valid((h)); } while (0)
+#define DUK_HSTRING_ASSERT_VALID(h) \
+	do { \
+		duk_hstring_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HSTRING_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HSTRING_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
 /*
@@ -6131,14 +6554,17 @@
  *  Prototypes
  */
 
-DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos, duk_bool_t surrogate_aware);
+DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr,
+                                                                duk_hstring *h,
+                                                                duk_uint_t pos,
+                                                                duk_bool_t surrogate_aware);
 DUK_INTERNAL_DECL duk_bool_t duk_hstring_equals_ascii_cstring(duk_hstring *h, const char *cstr);
 DUK_INTERNAL_DECL duk_size_t duk_hstring_get_charlen(duk_hstring *h);
 #if !defined(DUK_USE_HSTRING_LAZY_CLEN)
 DUK_INTERNAL_DECL void duk_hstring_init_charlen(duk_hstring *h);
 #endif
 
-#endif  /* DUK_HSTRING_H_INCLUDED */
+#endif /* DUK_HSTRING_H_INCLUDED */
 /* #include duk_hobject.h */
 #line 1 "duk_hobject.h"
 /*
@@ -6182,36 +6608,40 @@
 /* XXX: some flags are object subtype specific (e.g. common to all function
  * subtypes, duk_harray, etc) and could be reused for different subtypes.
  */
-#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_CALLABLE              DUK_HEAPHDR_USER_FLAG(2)   /* object is callable */
-#define DUK_HOBJECT_FLAG_BOUNDFUNC             DUK_HEAPHDR_USER_FLAG(3)   /* object established using Function.prototype.bind() */
-#define DUK_HOBJECT_FLAG_COMPFUNC              DUK_HEAPHDR_USER_FLAG(4)   /* object is a compiled function (duk_hcompfunc) */
-#define DUK_HOBJECT_FLAG_NATFUNC               DUK_HEAPHDR_USER_FLAG(5)   /* object is a native function (duk_hnatfunc) */
-#define DUK_HOBJECT_FLAG_BUFOBJ                DUK_HEAPHDR_USER_FLAG(6)   /* object is a buffer object (duk_hbufobj) (always exotic) */
-#define DUK_HOBJECT_FLAG_FASTREFS              DUK_HEAPHDR_USER_FLAG(7)   /* object has no fields needing DECREF/marking beyond base duk_hobject header */
-#define DUK_HOBJECT_FLAG_ARRAY_PART            DUK_HEAPHDR_USER_FLAG(8)   /* object has an array part (a_size may still be 0) */
-#define DUK_HOBJECT_FLAG_STRICT                DUK_HEAPHDR_USER_FLAG(9)   /* function: function object is strict */
-#define DUK_HOBJECT_FLAG_NOTAIL                DUK_HEAPHDR_USER_FLAG(10)  /* function: function must not be tail called */
-#define DUK_HOBJECT_FLAG_NEWENV                DUK_HEAPHDR_USER_FLAG(11)  /* function: create new environment when called (see duk_hcompfunc) */
-#define DUK_HOBJECT_FLAG_NAMEBINDING           DUK_HEAPHDR_USER_FLAG(12)  /* function: create binding for func name (function templates only, used for named function expressions) */
-#define DUK_HOBJECT_FLAG_CREATEARGS            DUK_HEAPHDR_USER_FLAG(13)  /* function: create an arguments object on function call */
-#define DUK_HOBJECT_FLAG_HAVE_FINALIZER        DUK_HEAPHDR_USER_FLAG(14)  /* object has a callable (own) finalizer property */
-#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY          DUK_HEAPHDR_USER_FLAG(15)  /* 'Array' object, array length and index exotic behavior */
-#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ      DUK_HEAPHDR_USER_FLAG(16)  /* 'String' object, array index exotic behavior */
-#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS      DUK_HEAPHDR_USER_FLAG(17)  /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */
-#define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ       DUK_HEAPHDR_USER_FLAG(18)  /* 'Proxy' object */
-#define DUK_HOBJECT_FLAG_SPECIAL_CALL          DUK_HEAPHDR_USER_FLAG(19)  /* special casing in call behavior, for .call(), .apply(), etc. */
+#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_CALLABLE      DUK_HEAPHDR_USER_FLAG(2) /* object is callable */
+#define DUK_HOBJECT_FLAG_BOUNDFUNC     DUK_HEAPHDR_USER_FLAG(3) /* object established using Function.prototype.bind() */
+#define DUK_HOBJECT_FLAG_COMPFUNC      DUK_HEAPHDR_USER_FLAG(4) /* object is a compiled function (duk_hcompfunc) */
+#define DUK_HOBJECT_FLAG_NATFUNC       DUK_HEAPHDR_USER_FLAG(5) /* object is a native function (duk_hnatfunc) */
+#define DUK_HOBJECT_FLAG_BUFOBJ        DUK_HEAPHDR_USER_FLAG(6) /* object is a buffer object (duk_hbufobj) (always exotic) */
+#define DUK_HOBJECT_FLAG_FASTREFS \
+	DUK_HEAPHDR_USER_FLAG(7) /* object has no fields needing DECREF/marking beyond base duk_hobject header */
+#define DUK_HOBJECT_FLAG_ARRAY_PART DUK_HEAPHDR_USER_FLAG(8) /* object has an array part (a_size may still be 0) */
+#define DUK_HOBJECT_FLAG_STRICT     DUK_HEAPHDR_USER_FLAG(9) /* function: function object is strict */
+#define DUK_HOBJECT_FLAG_NOTAIL     DUK_HEAPHDR_USER_FLAG(10) /* function: function must not be tail called */
+#define DUK_HOBJECT_FLAG_NEWENV     DUK_HEAPHDR_USER_FLAG(11) /* function: create new environment when called (see duk_hcompfunc) */
+#define DUK_HOBJECT_FLAG_NAMEBINDING \
+	DUK_HEAPHDR_USER_FLAG( \
+	    12) /* function: create binding for func name (function templates only, used for named function expressions) */
+#define DUK_HOBJECT_FLAG_CREATEARGS       DUK_HEAPHDR_USER_FLAG(13) /* function: create an arguments object on function call */
+#define DUK_HOBJECT_FLAG_HAVE_FINALIZER   DUK_HEAPHDR_USER_FLAG(14) /* object has a callable (own) finalizer property */
+#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY     DUK_HEAPHDR_USER_FLAG(15) /* 'Array' object, array length and index exotic behavior */
+#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ DUK_HEAPHDR_USER_FLAG(16) /* 'String' object, array index exotic behavior */
+#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS \
+	DUK_HEAPHDR_USER_FLAG(17) /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */
+#define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ DUK_HEAPHDR_USER_FLAG(18) /* 'Proxy' object */
+#define DUK_HOBJECT_FLAG_SPECIAL_CALL    DUK_HEAPHDR_USER_FLAG(19) /* special casing in call behavior, for .call(), .apply(), etc. */
 
-#define DUK_HOBJECT_FLAG_CLASS_BASE            DUK_HEAPHDR_USER_FLAG_NUMBER(20)
-#define DUK_HOBJECT_FLAG_CLASS_BITS            5
+#define DUK_HOBJECT_FLAG_CLASS_BASE DUK_HEAPHDR_USER_FLAG_NUMBER(20)
+#define DUK_HOBJECT_FLAG_CLASS_BITS 5
 
-#define DUK_HOBJECT_GET_CLASS_NUMBER(h)        \
+#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)      \
+#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))
 
-#define DUK_HOBJECT_GET_CLASS_MASK(h)          \
+#define DUK_HOBJECT_GET_CLASS_MASK(h) \
 	(1UL << DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS))
 
 /* Macro for creating flag initializer from a class number.
@@ -6219,256 +6649,239 @@
  * 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)
+#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_NONE                 0
-#define DUK_HOBJECT_CLASS_OBJECT               1
-#define DUK_HOBJECT_CLASS_ARRAY                2
-#define DUK_HOBJECT_CLASS_FUNCTION             3
-#define DUK_HOBJECT_CLASS_ARGUMENTS            4
-#define DUK_HOBJECT_CLASS_BOOLEAN              5
-#define DUK_HOBJECT_CLASS_DATE                 6
-#define DUK_HOBJECT_CLASS_ERROR                7
-#define DUK_HOBJECT_CLASS_JSON                 8
-#define DUK_HOBJECT_CLASS_MATH                 9
-#define DUK_HOBJECT_CLASS_NUMBER               10
-#define DUK_HOBJECT_CLASS_REGEXP               11
-#define DUK_HOBJECT_CLASS_STRING               12
-#define DUK_HOBJECT_CLASS_GLOBAL               13
-#define DUK_HOBJECT_CLASS_SYMBOL               14
-#define DUK_HOBJECT_CLASS_OBJENV               15  /* custom */
-#define DUK_HOBJECT_CLASS_DECENV               16  /* custom */
-#define DUK_HOBJECT_CLASS_POINTER              17  /* custom */
-#define DUK_HOBJECT_CLASS_THREAD               18  /* custom; implies DUK_HOBJECT_IS_THREAD */
-#define DUK_HOBJECT_CLASS_BUFOBJ_MIN           19
-#define DUK_HOBJECT_CLASS_ARRAYBUFFER          19  /* implies DUK_HOBJECT_IS_BUFOBJ */
-#define DUK_HOBJECT_CLASS_DATAVIEW             20
-#define DUK_HOBJECT_CLASS_INT8ARRAY            21
-#define DUK_HOBJECT_CLASS_UINT8ARRAY           22
-#define DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY    23
-#define DUK_HOBJECT_CLASS_INT16ARRAY           24
-#define DUK_HOBJECT_CLASS_UINT16ARRAY          25
-#define DUK_HOBJECT_CLASS_INT32ARRAY           26
-#define DUK_HOBJECT_CLASS_UINT32ARRAY          27
-#define DUK_HOBJECT_CLASS_FLOAT32ARRAY         28
-#define DUK_HOBJECT_CLASS_FLOAT64ARRAY         29
-#define DUK_HOBJECT_CLASS_BUFOBJ_MAX           29
-#define DUK_HOBJECT_CLASS_MAX                  29
+#define DUK_HOBJECT_CLASS_NONE              0
+#define DUK_HOBJECT_CLASS_OBJECT            1
+#define DUK_HOBJECT_CLASS_ARRAY             2
+#define DUK_HOBJECT_CLASS_FUNCTION          3
+#define DUK_HOBJECT_CLASS_ARGUMENTS         4
+#define DUK_HOBJECT_CLASS_BOOLEAN           5
+#define DUK_HOBJECT_CLASS_DATE              6
+#define DUK_HOBJECT_CLASS_ERROR             7
+#define DUK_HOBJECT_CLASS_JSON              8
+#define DUK_HOBJECT_CLASS_MATH              9
+#define DUK_HOBJECT_CLASS_NUMBER            10
+#define DUK_HOBJECT_CLASS_REGEXP            11
+#define DUK_HOBJECT_CLASS_STRING            12
+#define DUK_HOBJECT_CLASS_GLOBAL            13
+#define DUK_HOBJECT_CLASS_SYMBOL            14
+#define DUK_HOBJECT_CLASS_OBJENV            15 /* custom */
+#define DUK_HOBJECT_CLASS_DECENV            16 /* custom */
+#define DUK_HOBJECT_CLASS_POINTER           17 /* custom */
+#define DUK_HOBJECT_CLASS_THREAD            18 /* custom; implies DUK_HOBJECT_IS_THREAD */
+#define DUK_HOBJECT_CLASS_BUFOBJ_MIN        19
+#define DUK_HOBJECT_CLASS_ARRAYBUFFER       19 /* implies DUK_HOBJECT_IS_BUFOBJ */
+#define DUK_HOBJECT_CLASS_DATAVIEW          20
+#define DUK_HOBJECT_CLASS_INT8ARRAY         21
+#define DUK_HOBJECT_CLASS_UINT8ARRAY        22
+#define DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY 23
+#define DUK_HOBJECT_CLASS_INT16ARRAY        24
+#define DUK_HOBJECT_CLASS_UINT16ARRAY       25
+#define DUK_HOBJECT_CLASS_INT32ARRAY        26
+#define DUK_HOBJECT_CLASS_UINT32ARRAY       27
+#define DUK_HOBJECT_CLASS_FLOAT32ARRAY      28
+#define DUK_HOBJECT_CLASS_FLOAT64ARRAY      29
+#define DUK_HOBJECT_CLASS_BUFOBJ_MAX        29
+#define DUK_HOBJECT_CLASS_MAX               29
 
 /* Class masks. */
-#define DUK_HOBJECT_CMASK_ALL                  ((1UL << (DUK_HOBJECT_CLASS_MAX + 1)) - 1UL)
-#define DUK_HOBJECT_CMASK_NONE                 (1UL << DUK_HOBJECT_CLASS_NONE)
-#define DUK_HOBJECT_CMASK_ARGUMENTS            (1UL << DUK_HOBJECT_CLASS_ARGUMENTS)
-#define DUK_HOBJECT_CMASK_ARRAY                (1UL << DUK_HOBJECT_CLASS_ARRAY)
-#define DUK_HOBJECT_CMASK_BOOLEAN              (1UL << DUK_HOBJECT_CLASS_BOOLEAN)
-#define DUK_HOBJECT_CMASK_DATE                 (1UL << DUK_HOBJECT_CLASS_DATE)
-#define DUK_HOBJECT_CMASK_ERROR                (1UL << DUK_HOBJECT_CLASS_ERROR)
-#define DUK_HOBJECT_CMASK_FUNCTION             (1UL << DUK_HOBJECT_CLASS_FUNCTION)
-#define DUK_HOBJECT_CMASK_JSON                 (1UL << DUK_HOBJECT_CLASS_JSON)
-#define DUK_HOBJECT_CMASK_MATH                 (1UL << DUK_HOBJECT_CLASS_MATH)
-#define DUK_HOBJECT_CMASK_NUMBER               (1UL << DUK_HOBJECT_CLASS_NUMBER)
-#define DUK_HOBJECT_CMASK_OBJECT               (1UL << DUK_HOBJECT_CLASS_OBJECT)
-#define DUK_HOBJECT_CMASK_REGEXP               (1UL << DUK_HOBJECT_CLASS_REGEXP)
-#define DUK_HOBJECT_CMASK_STRING               (1UL << DUK_HOBJECT_CLASS_STRING)
-#define DUK_HOBJECT_CMASK_GLOBAL               (1UL << DUK_HOBJECT_CLASS_GLOBAL)
-#define DUK_HOBJECT_CMASK_SYMBOL               (1UL << DUK_HOBJECT_CLASS_SYMBOL)
-#define DUK_HOBJECT_CMASK_OBJENV               (1UL << DUK_HOBJECT_CLASS_OBJENV)
-#define DUK_HOBJECT_CMASK_DECENV               (1UL << DUK_HOBJECT_CLASS_DECENV)
-#define DUK_HOBJECT_CMASK_POINTER              (1UL << DUK_HOBJECT_CLASS_POINTER)
-#define DUK_HOBJECT_CMASK_ARRAYBUFFER          (1UL << DUK_HOBJECT_CLASS_ARRAYBUFFER)
-#define DUK_HOBJECT_CMASK_DATAVIEW             (1UL << DUK_HOBJECT_CLASS_DATAVIEW)
-#define DUK_HOBJECT_CMASK_INT8ARRAY            (1UL << DUK_HOBJECT_CLASS_INT8ARRAY)
-#define DUK_HOBJECT_CMASK_UINT8ARRAY           (1UL << DUK_HOBJECT_CLASS_UINT8ARRAY)
-#define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY    (1UL << DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY)
-#define DUK_HOBJECT_CMASK_INT16ARRAY           (1UL << DUK_HOBJECT_CLASS_INT16ARRAY)
-#define DUK_HOBJECT_CMASK_UINT16ARRAY          (1UL << DUK_HOBJECT_CLASS_UINT16ARRAY)
-#define DUK_HOBJECT_CMASK_INT32ARRAY           (1UL << DUK_HOBJECT_CLASS_INT32ARRAY)
-#define DUK_HOBJECT_CMASK_UINT32ARRAY          (1UL << DUK_HOBJECT_CLASS_UINT32ARRAY)
-#define DUK_HOBJECT_CMASK_FLOAT32ARRAY         (1UL << DUK_HOBJECT_CLASS_FLOAT32ARRAY)
-#define DUK_HOBJECT_CMASK_FLOAT64ARRAY         (1UL << DUK_HOBJECT_CLASS_FLOAT64ARRAY)
+#define DUK_HOBJECT_CMASK_ALL               ((1UL << (DUK_HOBJECT_CLASS_MAX + 1)) - 1UL)
+#define DUK_HOBJECT_CMASK_NONE              (1UL << DUK_HOBJECT_CLASS_NONE)
+#define DUK_HOBJECT_CMASK_ARGUMENTS         (1UL << DUK_HOBJECT_CLASS_ARGUMENTS)
+#define DUK_HOBJECT_CMASK_ARRAY             (1UL << DUK_HOBJECT_CLASS_ARRAY)
+#define DUK_HOBJECT_CMASK_BOOLEAN           (1UL << DUK_HOBJECT_CLASS_BOOLEAN)
+#define DUK_HOBJECT_CMASK_DATE              (1UL << DUK_HOBJECT_CLASS_DATE)
+#define DUK_HOBJECT_CMASK_ERROR             (1UL << DUK_HOBJECT_CLASS_ERROR)
+#define DUK_HOBJECT_CMASK_FUNCTION          (1UL << DUK_HOBJECT_CLASS_FUNCTION)
+#define DUK_HOBJECT_CMASK_JSON              (1UL << DUK_HOBJECT_CLASS_JSON)
+#define DUK_HOBJECT_CMASK_MATH              (1UL << DUK_HOBJECT_CLASS_MATH)
+#define DUK_HOBJECT_CMASK_NUMBER            (1UL << DUK_HOBJECT_CLASS_NUMBER)
+#define DUK_HOBJECT_CMASK_OBJECT            (1UL << DUK_HOBJECT_CLASS_OBJECT)
+#define DUK_HOBJECT_CMASK_REGEXP            (1UL << DUK_HOBJECT_CLASS_REGEXP)
+#define DUK_HOBJECT_CMASK_STRING            (1UL << DUK_HOBJECT_CLASS_STRING)
+#define DUK_HOBJECT_CMASK_GLOBAL            (1UL << DUK_HOBJECT_CLASS_GLOBAL)
+#define DUK_HOBJECT_CMASK_SYMBOL            (1UL << DUK_HOBJECT_CLASS_SYMBOL)
+#define DUK_HOBJECT_CMASK_OBJENV            (1UL << DUK_HOBJECT_CLASS_OBJENV)
+#define DUK_HOBJECT_CMASK_DECENV            (1UL << DUK_HOBJECT_CLASS_DECENV)
+#define DUK_HOBJECT_CMASK_POINTER           (1UL << DUK_HOBJECT_CLASS_POINTER)
+#define DUK_HOBJECT_CMASK_ARRAYBUFFER       (1UL << DUK_HOBJECT_CLASS_ARRAYBUFFER)
+#define DUK_HOBJECT_CMASK_DATAVIEW          (1UL << DUK_HOBJECT_CLASS_DATAVIEW)
+#define DUK_HOBJECT_CMASK_INT8ARRAY         (1UL << DUK_HOBJECT_CLASS_INT8ARRAY)
+#define DUK_HOBJECT_CMASK_UINT8ARRAY        (1UL << DUK_HOBJECT_CLASS_UINT8ARRAY)
+#define DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY (1UL << DUK_HOBJECT_CLASS_UINT8CLAMPEDARRAY)
+#define DUK_HOBJECT_CMASK_INT16ARRAY        (1UL << DUK_HOBJECT_CLASS_INT16ARRAY)
+#define DUK_HOBJECT_CMASK_UINT16ARRAY       (1UL << DUK_HOBJECT_CLASS_UINT16ARRAY)
+#define DUK_HOBJECT_CMASK_INT32ARRAY        (1UL << DUK_HOBJECT_CLASS_INT32ARRAY)
+#define DUK_HOBJECT_CMASK_UINT32ARRAY       (1UL << DUK_HOBJECT_CLASS_UINT32ARRAY)
+#define DUK_HOBJECT_CMASK_FLOAT32ARRAY      (1UL << DUK_HOBJECT_CLASS_FLOAT32ARRAY)
+#define DUK_HOBJECT_CMASK_FLOAT64ARRAY      (1UL << DUK_HOBJECT_CLASS_FLOAT64ARRAY)
 
 #define DUK_HOBJECT_CMASK_ALL_BUFOBJS \
-	(DUK_HOBJECT_CMASK_ARRAYBUFFER | \
-	 DUK_HOBJECT_CMASK_DATAVIEW | \
-	 DUK_HOBJECT_CMASK_INT8ARRAY | \
-	 DUK_HOBJECT_CMASK_UINT8ARRAY | \
-	 DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY | \
-	 DUK_HOBJECT_CMASK_INT16ARRAY | \
-	 DUK_HOBJECT_CMASK_UINT16ARRAY | \
-	 DUK_HOBJECT_CMASK_INT32ARRAY | \
-	 DUK_HOBJECT_CMASK_UINT32ARRAY | \
-	 DUK_HOBJECT_CMASK_FLOAT32ARRAY | \
+	(DUK_HOBJECT_CMASK_ARRAYBUFFER | DUK_HOBJECT_CMASK_DATAVIEW | DUK_HOBJECT_CMASK_INT8ARRAY | DUK_HOBJECT_CMASK_UINT8ARRAY | \
+	 DUK_HOBJECT_CMASK_UINT8CLAMPEDARRAY | DUK_HOBJECT_CMASK_INT16ARRAY | DUK_HOBJECT_CMASK_UINT16ARRAY | \
+	 DUK_HOBJECT_CMASK_INT32ARRAY | DUK_HOBJECT_CMASK_UINT32ARRAY | DUK_HOBJECT_CMASK_FLOAT32ARRAY | \
 	 DUK_HOBJECT_CMASK_FLOAT64ARRAY)
 
-#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_HAS_EXOTIC_ARRAY((h))  /* Rely on class Array <=> exotic Array */
-#define DUK_HOBJECT_IS_BOUNDFUNC(h)            DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
-#define DUK_HOBJECT_IS_COMPFUNC(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
-#define DUK_HOBJECT_IS_NATFUNC(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
+#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_HAS_EXOTIC_ARRAY((h)) /* Rely on class Array <=> exotic Array */
+#define DUK_HOBJECT_IS_BOUNDFUNC(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
+#define DUK_HOBJECT_IS_COMPFUNC(h)  DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
+#define DUK_HOBJECT_IS_NATFUNC(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
 #if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
-#define DUK_HOBJECT_IS_BUFOBJ(h)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
+#define DUK_HOBJECT_IS_BUFOBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
 #else
-#define DUK_HOBJECT_IS_BUFOBJ(h)               0
+#define DUK_HOBJECT_IS_BUFOBJ(h) 0
 #endif
-#define DUK_HOBJECT_IS_THREAD(h)               (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_THREAD)
+#define DUK_HOBJECT_IS_THREAD(h) (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_THREAD)
 #if defined(DUK_USE_ES6_PROXY)
-#define DUK_HOBJECT_IS_PROXY(h)                DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ((h))
+#define DUK_HOBJECT_IS_PROXY(h) DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ((h))
 #else
-#define DUK_HOBJECT_IS_PROXY(h)                0
+#define DUK_HOBJECT_IS_PROXY(h) 0
 #endif
 
-#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
-                                                        DUK_HOBJECT_FLAG_COMPFUNC | \
-                                                        DUK_HOBJECT_FLAG_NATFUNC)
+#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h) \
+	DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC | DUK_HOBJECT_FLAG_NATFUNC)
 
-#define DUK_HOBJECT_IS_FUNCTION(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
-                                                        DUK_HOBJECT_FLAG_BOUNDFUNC | \
-                                                        DUK_HOBJECT_FLAG_COMPFUNC | \
-                                                        DUK_HOBJECT_FLAG_NATFUNC)
+#define DUK_HOBJECT_IS_FUNCTION(h) \
+	DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC | DUK_HOBJECT_FLAG_COMPFUNC | DUK_HOBJECT_FLAG_NATFUNC)
 
-#define DUK_HOBJECT_IS_CALLABLE(h)             DUK_HOBJECT_HAS_CALLABLE((h))
+#define DUK_HOBJECT_IS_CALLABLE(h) DUK_HOBJECT_HAS_CALLABLE((h))
 
 /* 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_BUFOBJ | \
-                                                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_EXOTIC_BEHAVIOR_FLAGS \
+	(DUK_HOBJECT_FLAG_EXOTIC_ARRAY | DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS | DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \
+	 DUK_HOBJECT_FLAG_BUFOBJ | DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
+#define DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS)
 
 /* Object has any virtual properties (not counting Proxy behavior). */
-#define DUK_HOBJECT_VIRTUAL_PROPERTY_FLAGS     (DUK_HOBJECT_FLAG_EXOTIC_ARRAY | \
-                                                DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \
-                                                DUK_HOBJECT_FLAG_BUFOBJ)
-#define DUK_HOBJECT_HAS_VIRTUAL_PROPERTIES(h)  DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_VIRTUAL_PROPERTY_FLAGS)
+#define DUK_HOBJECT_VIRTUAL_PROPERTY_FLAGS \
+	(DUK_HOBJECT_FLAG_EXOTIC_ARRAY | DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | DUK_HOBJECT_FLAG_BUFOBJ)
+#define DUK_HOBJECT_HAS_VIRTUAL_PROPERTIES(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_VIRTUAL_PROPERTY_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_CALLABLE(h)            DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
-#define DUK_HOBJECT_HAS_BOUNDFUNC(h)           DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
-#define DUK_HOBJECT_HAS_COMPFUNC(h)            DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
-#define DUK_HOBJECT_HAS_NATFUNC(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
+#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_CALLABLE(h)      DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
+#define DUK_HOBJECT_HAS_BOUNDFUNC(h)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
+#define DUK_HOBJECT_HAS_COMPFUNC(h)      DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
+#define DUK_HOBJECT_HAS_NATFUNC(h)       DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
 #if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
-#define DUK_HOBJECT_HAS_BUFOBJ(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
+#define DUK_HOBJECT_HAS_BUFOBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
 #else
-#define DUK_HOBJECT_HAS_BUFOBJ(h)              0
+#define DUK_HOBJECT_HAS_BUFOBJ(h) 0
 #endif
-#define DUK_HOBJECT_HAS_FASTREFS(h)            DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
-#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_HAVE_FINALIZER(h)      DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
-#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_FASTREFS(h)         DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
+#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_HAVE_FINALIZER(h)   DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
+#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)
 #if defined(DUK_USE_ES6_PROXY)
-#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
+#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
 #else
-#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)     0
+#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h) 0
 #endif
-#define DUK_HOBJECT_HAS_SPECIAL_CALL(h)        DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
+#define DUK_HOBJECT_HAS_SPECIAL_CALL(h) DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
 
-#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_CALLABLE(h)            DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
-#define DUK_HOBJECT_SET_BOUNDFUNC(h)           DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
-#define DUK_HOBJECT_SET_COMPFUNC(h)            DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
-#define DUK_HOBJECT_SET_NATFUNC(h)             DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
+#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_CALLABLE(h)      DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
+#define DUK_HOBJECT_SET_BOUNDFUNC(h)     DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
+#define DUK_HOBJECT_SET_COMPFUNC(h)      DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
+#define DUK_HOBJECT_SET_NATFUNC(h)       DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
 #if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
-#define DUK_HOBJECT_SET_BUFOBJ(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
+#define DUK_HOBJECT_SET_BUFOBJ(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
 #endif
-#define DUK_HOBJECT_SET_FASTREFS(h)            DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
-#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_HAVE_FINALIZER(h)      DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
-#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_FASTREFS(h)         DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
+#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_HAVE_FINALIZER(h)   DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
+#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)
 #if defined(DUK_USE_ES6_PROXY)
-#define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ(h)     DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
+#define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
 #endif
-#define DUK_HOBJECT_SET_SPECIAL_CALL(h)        DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
+#define DUK_HOBJECT_SET_SPECIAL_CALL(h) DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
 
-#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_CALLABLE(h)          DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
-#define DUK_HOBJECT_CLEAR_BOUNDFUNC(h)         DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
-#define DUK_HOBJECT_CLEAR_COMPFUNC(h)          DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
-#define DUK_HOBJECT_CLEAR_NATFUNC(h)           DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
+#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_CALLABLE(h)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CALLABLE)
+#define DUK_HOBJECT_CLEAR_BOUNDFUNC(h)     DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUNDFUNC)
+#define DUK_HOBJECT_CLEAR_COMPFUNC(h)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPFUNC)
+#define DUK_HOBJECT_CLEAR_NATFUNC(h)       DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATFUNC)
 #if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
-#define DUK_HOBJECT_CLEAR_BUFOBJ(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
+#define DUK_HOBJECT_CLEAR_BUFOBJ(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BUFOBJ)
 #endif
-#define DUK_HOBJECT_CLEAR_FASTREFS(h)          DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
-#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_HAVE_FINALIZER(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
-#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_FASTREFS(h)         DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_FASTREFS)
+#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_HAVE_FINALIZER(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_HAVE_FINALIZER)
+#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)
 #if defined(DUK_USE_ES6_PROXY)
-#define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
+#define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
 #endif
-#define DUK_HOBJECT_CLEAR_SPECIAL_CALL(h)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
+#define DUK_HOBJECT_CLEAR_SPECIAL_CALL(h) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_SPECIAL_CALL)
 
 /* Object can/cannot use FASTREFS, i.e. has no strong reference fields beyond
  * duk_hobject base header.  This is used just for asserts so doesn't need to
  * be optimized.
  */
 #define DUK_HOBJECT_PROHIBITS_FASTREFS(h) \
-	(DUK_HOBJECT_IS_COMPFUNC((h)) || DUK_HOBJECT_IS_DECENV((h)) || DUK_HOBJECT_IS_OBJENV((h)) || \
-	 DUK_HOBJECT_IS_BUFOBJ((h)) || DUK_HOBJECT_IS_THREAD((h)) || DUK_HOBJECT_IS_PROXY((h)) || \
-	 DUK_HOBJECT_IS_BOUNDFUNC((h)))
+	(DUK_HOBJECT_IS_COMPFUNC((h)) || DUK_HOBJECT_IS_DECENV((h)) || DUK_HOBJECT_IS_OBJENV((h)) || DUK_HOBJECT_IS_BUFOBJ((h)) || \
+	 DUK_HOBJECT_IS_THREAD((h)) || DUK_HOBJECT_IS_PROXY((h)) || DUK_HOBJECT_IS_BOUNDFUNC((h)))
 #define DUK_HOBJECT_ALLOWS_FASTREFS(h) (!DUK_HOBJECT_PROHIBITS_FASTREFS((h)))
 
 /* Flags used for property attributes in duk_propdesc and packed flags.
  * Must fit into 8 bits.
  */
-#define DUK_PROPDESC_FLAG_WRITABLE              (1U << 0)    /* E5 Section 8.6.1 */
-#define DUK_PROPDESC_FLAG_ENUMERABLE            (1U << 1)    /* E5 Section 8.6.1 */
-#define DUK_PROPDESC_FLAG_CONFIGURABLE          (1U << 2)    /* E5 Section 8.6.1 */
-#define DUK_PROPDESC_FLAG_ACCESSOR              (1U << 3)    /* accessor */
-#define DUK_PROPDESC_FLAG_VIRTUAL               (1U << 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)
+#define DUK_PROPDESC_FLAG_WRITABLE     (1U << 0) /* E5 Section 8.6.1 */
+#define DUK_PROPDESC_FLAG_ENUMERABLE   (1U << 1) /* E5 Section 8.6.1 */
+#define DUK_PROPDESC_FLAG_CONFIGURABLE (1U << 2) /* E5 Section 8.6.1 */
+#define DUK_PROPDESC_FLAG_ACCESSOR     (1U << 3) /* accessor */
+#define DUK_PROPDESC_FLAG_VIRTUAL \
+	(1U << 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          (1U << 4)    /* internal define property: skip write silently if exists */
+#define DUK_PROPDESC_FLAG_NO_OVERWRITE (1U << 4) /* internal define property: skip write silently if exists */
 
 /* Convenience defines for property attributes. */
-#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)
+#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)
 
 /* Flags for duk_hobject_get_own_propdesc() and variants. */
-#define DUK_GETDESC_FLAG_PUSH_VALUE          (1U << 0)  /* push value to stack */
-#define DUK_GETDESC_FLAG_IGNORE_PROTOLOOP    (1U << 1)  /* don't throw for prototype loop */
+#define DUK_GETDESC_FLAG_PUSH_VALUE       (1U << 0) /* push value to stack */
+#define DUK_GETDESC_FLAG_IGNORE_PROTOLOOP (1U << 1) /* don't throw for prototype loop */
 
 /*
  *  Macro for object validity check
@@ -6478,9 +6891,14 @@
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hobject_assert_valid(duk_hobject *h);
-#define DUK_HOBJECT_ASSERT_VALID(h)  do { duk_hobject_assert_valid((h)); } while (0)
+#define DUK_HOBJECT_ASSERT_VALID(h) \
+	do { \
+		duk_hobject_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HOBJECT_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HOBJECT_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
 /*
@@ -6488,52 +6906,41 @@
  */
 
 #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 { \
+#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 { \
+#define DUK_HOBJECT_GET_PROPS(heap, h) ((h)->props)
+#define DUK_HOBJECT_SET_PROPS(heap, h, x) \
+	do { \
 		(h)->props = (duk_uint8_t *) (x); \
 	} while (0)
 #endif
 
 #if defined(DUK_USE_HOBJECT_LAYOUT_1)
 /* LAYOUT 1 */
-#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
-	((duk_hstring **) (void *) ( \
-		DUK_HOBJECT_GET_PROPS((heap), (h)) \
-	))
-#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
-	((duk_propvalue *) (void *) ( \
-		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 *) (void *) ( \
-		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 *) (void *) ( \
-		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 *) (void *) ( \
-		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 { \
+#define DUK_HOBJECT_E_GET_KEY_BASE(heap, h) ((duk_hstring **) (void *) (DUK_HOBJECT_GET_PROPS((heap), (h))))
+#define DUK_HOBJECT_E_GET_VALUE_BASE(heap, h) \
+	((duk_propvalue *) (void *) (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 *) (void *) (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 *) (void *) (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 *) (void *) (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 **) (void *) (p_base); \
 		(set_e_pv) = (duk_propvalue *) (void *) ((set_e_k) + (n_ent)); \
 		(set_e_f) = (duk_uint8_t *) (void *) ((set_e_pv) + (n_ent)); \
@@ -6551,85 +6958,57 @@
 #else
 #error invalid DUK_USE_ALIGN_BY
 #endif
-#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
-	((duk_hstring **) (void *) ( \
-		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 *) (void *) ( \
-		DUK_HOBJECT_GET_PROPS((heap), (h)) \
-	))
-#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
-	((duk_uint8_t *) (void *) ( \
-		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 *) (void *) ( \
-		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 *) (void *) ( \
-		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 { \
+#define DUK_HOBJECT_E_GET_KEY_BASE(heap, h) \
+	((duk_hstring **) (void *) (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 *) (void *) (DUK_HOBJECT_GET_PROPS((heap), (h))))
+#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap, h) \
+	((duk_uint8_t *) (void *) (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 *) (void *) (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 *) (void *) (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 *) (void *) (p_base); \
 		(set_e_k) = (duk_hstring **) (void *) ((set_e_pv) + (n_ent)); \
 		(set_e_f) = (duk_uint8_t *) (void *) ((set_e_k) + (n_ent)); \
-		(set_a) = (duk_tval *) (void *) (((duk_uint8_t *) (set_e_f)) + \
-		                                 sizeof(duk_uint8_t) * (n_ent) + \
+		(set_a) = (duk_tval *) (void *) (((duk_uint8_t *) (set_e_f)) + sizeof(duk_uint8_t) * (n_ent) + \
 		                                 DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \
 		(set_h) = (duk_uint32_t *) (void *) ((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 **) (void *) ( \
-		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 *) (void *) ( \
-		DUK_HOBJECT_GET_PROPS((heap), (h)) \
-	))
-#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
-	((duk_uint8_t *) (void *) ( \
-		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 *) (void *) ( \
-		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 *) (void *) ( \
-		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 { \
+#define DUK_HOBJECT_E_GET_KEY_BASE(heap, h) \
+	((duk_hstring **) (void *) (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 *) (void *) (DUK_HOBJECT_GET_PROPS((heap), (h))))
+#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap, h) \
+	((duk_uint8_t *) (void *) (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 *) (void *) (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 *) (void *) (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 *) (void *) (p_base); \
 		(set_a) = (duk_tval *) (void *) ((set_e_pv) + (n_ent)); \
 		(set_e_k) = (duk_hstring **) (void *) ((set_a) + (n_arr)); \
@@ -6638,85 +7017,99 @@
 	} while (0)
 #else
 #error invalid hobject layout defines
-#endif  /* hobject property layout */
+#endif /* hobject property layout */
 
 #define DUK_HOBJECT_P_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_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 { \
+#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 { \
+#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 { \
+#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 { \
+#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 { \
+#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 { \
+#define DUK_HOBJECT_E_SET_FLAGS(heap, h, i, f) \
+	do { \
 		DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (duk_uint8_t) (f); \
 	} while (0)
-#define DUK_HOBJECT_A_SET_VALUE(heap,h,i,v)  do { \
+#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 { \
+#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 { \
+#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 { \
+#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_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_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_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_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
+#define DUK_HOBJECT_HASHIDX_UNUSED  0xffffffffUL
+#define DUK_HOBJECT_HASHIDX_DELETED 0xfffffffeUL
 
 /*
  *  Macros for accessing size fields
@@ -6724,33 +7117,63 @@
 
 #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_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_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)
+#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)
+#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)
+#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_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_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)
+#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)
+#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)
+#define DUK_HOBJECT_SET_HSIZE(h, v) \
+	do { \
+		DUK_ASSERT((v) == 0); \
+	} while (0)
 #endif
 #endif
 
@@ -6761,46 +7184,44 @@
 /* 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
+#define DUK_HOBJECT_PROTOTYPE_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_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))) \
-	)
+#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 { \
+#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 { \
+#define DUK_HOBJECT_GET_PROTOTYPE(heap, h) ((h)->prototype)
+#define DUK_HOBJECT_SET_PROTOTYPE(heap, h, x) \
+	do { \
 		(h)->prototype = (x); \
 	} while (0)
 #endif
 
 /* Set prototype, DECREF earlier value, INCREF new value (tolerating NULLs). */
-#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr,h,p)       duk_hobject_set_prototype_updref((thr), (h), (p))
+#define DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, p) duk_hobject_set_prototype_updref((thr), (h), (p))
 
 /* Set initial prototype, assume NULL previous prototype, INCREF new value,
  * tolerate NULL.
  */
-#define DUK_HOBJECT_SET_PROTOTYPE_INIT_INCREF(thr,h,proto) do { \
+#define DUK_HOBJECT_SET_PROTOTYPE_INIT_INCREF(thr, h, proto) \
+	do { \
 		duk_hthread *duk__thr = (thr); \
 		duk_hobject *duk__obj = (h); \
 		duk_hobject *duk__proto = (proto); \
@@ -6815,9 +7236,9 @@
  */
 
 #if defined(DUK_USE_HEAPPTR16)
-#define DUK_HOBJECT_HAS_FINALIZER_FAST(heap,h) duk_hobject_has_finalizer_fast_raw((heap), (h))
+#define DUK_HOBJECT_HAS_FINALIZER_FAST(heap, h) duk_hobject_has_finalizer_fast_raw((heap), (h))
 #else
-#define DUK_HOBJECT_HAS_FINALIZER_FAST(heap,h) duk_hobject_has_finalizer_fast_raw((h))
+#define DUK_HOBJECT_HAS_FINALIZER_FAST(heap, h) duk_hobject_has_finalizer_fast_raw((h))
 #endif
 
 /*
@@ -6831,18 +7252,18 @@
  * so anything above 0x80000000 will cause trouble now.
  */
 #if defined(DUK_USE_OBJSIZES16)
-#define DUK_HOBJECT_MAX_PROPERTIES       0x0000ffffUL
+#define DUK_HOBJECT_MAX_PROPERTIES 0x0000ffffUL
 #else
-#define DUK_HOBJECT_MAX_PROPERTIES       0x3fffffffUL   /* 2**30-1 ~= 1G properties */
+#define DUK_HOBJECT_MAX_PROPERTIES 0x3fffffffUL /* 2**30-1 ~= 1G properties */
 #endif
 
 /* internal align target for props allocation, must be 2*n for some n */
 #if (DUK_USE_ALIGN_BY == 4)
-#define DUK_HOBJECT_ALIGN_TARGET         4
+#define DUK_HOBJECT_ALIGN_TARGET 4
 #elif (DUK_USE_ALIGN_BY == 8)
-#define DUK_HOBJECT_ALIGN_TARGET         8
+#define DUK_HOBJECT_ALIGN_TARGET 8
 #elif (DUK_USE_ALIGN_BY == 1)
-#define DUK_HOBJECT_ALIGN_TARGET         1
+#define DUK_HOBJECT_ALIGN_TARGET 1
 #else
 #error invalid DUK_USE_ALIGN_BY
 #endif
@@ -6851,10 +7272,10 @@
  *  PC-to-line constants
  */
 
-#define DUK_PC2LINE_SKIP    64
+#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)
+#define DUK_PC2LINE_MAX_DIFF_LENGTH (((DUK_PC2LINE_SKIP - 1) * 35 + 7) / 8)
 
 /*
  *  Struct defs
@@ -6881,9 +7302,9 @@
 	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 */
+	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 {
@@ -6978,11 +7399,11 @@
 	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) */
+	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 */
+	duk_uint32_t h_size; /* hash part size or 0 if unused */
 #endif
 #endif
 };
@@ -6993,7 +7414,7 @@
 
 #if !defined(DUK_SINGLE_FILE)
 DUK_INTERNAL_DECL duk_uint8_t duk_class_number_to_stridx[32];
-#endif  /* !DUK_SINGLE_FILE */
+#endif /* !DUK_SINGLE_FILE */
 
 /*
  *  Prototypes
@@ -7022,36 +7443,46 @@
                                                  duk_uint32_t new_a_size,
                                                  duk_uint32_t new_h_size,
                                                  duk_bool_t abandon_array);
-DUK_INTERNAL_DECL void duk_hobject_resize_entrypart(duk_hthread *thr,
-                                                    duk_hobject *obj,
-                                                    duk_uint32_t new_e_size);
-#if 0  /*unused*/
+DUK_INTERNAL_DECL void duk_hobject_resize_entrypart(duk_hthread *thr, duk_hobject *obj, duk_uint32_t new_e_size);
+#if 0 /*unused*/
 DUK_INTERNAL_DECL void duk_hobject_resize_arraypart(duk_hthread *thr,
                                                     duk_hobject *obj,
                                                     duk_uint32_t new_a_size);
 #endif
 
 /* low-level property functions */
-DUK_INTERNAL_DECL duk_bool_t duk_hobject_find_entry(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_int_t *e_idx, duk_int_t *h_idx);
+DUK_INTERNAL_DECL duk_bool_t
+duk_hobject_find_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_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_hstring *key);
 DUK_INTERNAL_DECL duk_tval *duk_hobject_find_entry_tval_ptr_stridx(duk_heap *heap, duk_hobject *obj, duk_small_uint_t stridx);
-DUK_INTERNAL_DECL duk_tval *duk_hobject_find_entry_tval_ptr_and_attrs(duk_heap *heap, duk_hobject *obj, duk_hstring *key, duk_uint_t *out_attrs);
+DUK_INTERNAL_DECL duk_tval *duk_hobject_find_entry_tval_ptr_and_attrs(duk_heap *heap,
+                                                                      duk_hobject *obj,
+                                                                      duk_hstring *key,
+                                                                      duk_uint_t *out_attrs);
 DUK_INTERNAL_DECL duk_tval *duk_hobject_find_array_entry_tval_ptr(duk_heap *heap, duk_hobject *obj, duk_uarridx_t i);
-DUK_INTERNAL_DECL duk_bool_t duk_hobject_get_own_propdesc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags);
+DUK_INTERNAL_DECL duk_bool_t
+duk_hobject_get_own_propdesc(duk_hthread *thr, duk_hobject *obj, duk_hstring *key, duk_propdesc *out_desc, duk_small_uint_t flags);
 
 /* 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_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  (1U << 0)
-#define DUK_DELPROP_FLAG_FORCE  (1U << 1)
+#define DUK_DELPROP_FLAG_THROW (1U << 0)
+#define DUK_DELPROP_FLAG_FORCE (1U << 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_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 duk_size_t duk_hobject_get_length(duk_hthread *thr, duk_hobject *obj);
 #if defined(DUK_USE_HEAPPTR16)
 DUK_INTERNAL_DECL duk_bool_t duk_hobject_has_finalizer_fast_raw(duk_heap *heap, duk_hobject *obj);
@@ -7111,7 +7542,10 @@
 #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);
+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);
 
 #if !defined(DUK_USE_OBJECT_BUILTIN)
 /* These declarations are needed when related built-in is disabled and
@@ -7121,7 +7555,7 @@
 DUK_INTERNAL_DECL duk_ret_t duk_bi_function_prototype(duk_hthread *thr);
 #endif
 
-#endif  /* DUK_HOBJECT_H_INCLUDED */
+#endif /* DUK_HOBJECT_H_INCLUDED */
 /* #include duk_hcompfunc.h */
 #line 1 "duk_hcompfunc.h"
 /*
@@ -7141,50 +7575,55 @@
 /* XXX: casts could be improved, especially for GET/SET DATA */
 
 #if defined(DUK_USE_HEAPPTR16)
-#define DUK_HCOMPFUNC_GET_DATA(heap,h) \
-	((duk_hbuffer_fixed *) (void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->data16))
-#define DUK_HCOMPFUNC_SET_DATA(heap,h,v) do { \
+#define DUK_HCOMPFUNC_GET_DATA(heap, h) ((duk_hbuffer_fixed *) (void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->data16))
+#define DUK_HCOMPFUNC_SET_DATA(heap, h, v) \
+	do { \
 		(h)->data16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
 	} while (0)
-#define DUK_HCOMPFUNC_GET_FUNCS(heap,h)  \
-	((duk_hobject **) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->funcs16)))
-#define DUK_HCOMPFUNC_SET_FUNCS(heap,h,v)  do { \
+#define DUK_HCOMPFUNC_GET_FUNCS(heap, h) ((duk_hobject **) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->funcs16)))
+#define DUK_HCOMPFUNC_SET_FUNCS(heap, h, v) \
+	do { \
 		(h)->funcs16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
 	} while (0)
-#define DUK_HCOMPFUNC_GET_BYTECODE(heap,h)  \
-	((duk_instr_t *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->bytecode16)))
-#define DUK_HCOMPFUNC_SET_BYTECODE(heap,h,v)  do { \
+#define DUK_HCOMPFUNC_GET_BYTECODE(heap, h) ((duk_instr_t *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->bytecode16)))
+#define DUK_HCOMPFUNC_SET_BYTECODE(heap, h, v) \
+	do { \
 		(h)->bytecode16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
 	} while (0)
-#define DUK_HCOMPFUNC_GET_LEXENV(heap,h)  \
-	((duk_hobject *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->lex_env16)))
-#define DUK_HCOMPFUNC_SET_LEXENV(heap,h,v)  do { \
+#define DUK_HCOMPFUNC_GET_LEXENV(heap, h) ((duk_hobject *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->lex_env16)))
+#define DUK_HCOMPFUNC_SET_LEXENV(heap, h, v) \
+	do { \
 		(h)->lex_env16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
 	} while (0)
-#define DUK_HCOMPFUNC_GET_VARENV(heap,h)  \
-	((duk_hobject *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->var_env16)))
-#define DUK_HCOMPFUNC_SET_VARENV(heap,h,v)  do { \
+#define DUK_HCOMPFUNC_GET_VARENV(heap, h) ((duk_hobject *) (void *) (DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->var_env16)))
+#define DUK_HCOMPFUNC_SET_VARENV(heap, h, v) \
+	do { \
 		(h)->var_env16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
 	} while (0)
 #else
-#define DUK_HCOMPFUNC_GET_DATA(heap,h)  ((duk_hbuffer_fixed *) (void *) (h)->data)
-#define DUK_HCOMPFUNC_SET_DATA(heap,h,v) do { \
+#define DUK_HCOMPFUNC_GET_DATA(heap, h) ((duk_hbuffer_fixed *) (void *) (h)->data)
+#define DUK_HCOMPFUNC_SET_DATA(heap, h, v) \
+	do { \
 		(h)->data = (duk_hbuffer *) (v); \
 	} while (0)
-#define DUK_HCOMPFUNC_GET_FUNCS(heap,h)  ((h)->funcs)
-#define DUK_HCOMPFUNC_SET_FUNCS(heap,h,v)  do { \
+#define DUK_HCOMPFUNC_GET_FUNCS(heap, h) ((h)->funcs)
+#define DUK_HCOMPFUNC_SET_FUNCS(heap, h, v) \
+	do { \
 		(h)->funcs = (v); \
 	} while (0)
-#define DUK_HCOMPFUNC_GET_BYTECODE(heap,h)  ((h)->bytecode)
-#define DUK_HCOMPFUNC_SET_BYTECODE(heap,h,v)  do { \
+#define DUK_HCOMPFUNC_GET_BYTECODE(heap, h) ((h)->bytecode)
+#define DUK_HCOMPFUNC_SET_BYTECODE(heap, h, v) \
+	do { \
 		(h)->bytecode = (v); \
 	} while (0)
-#define DUK_HCOMPFUNC_GET_LEXENV(heap,h)  ((h)->lex_env)
-#define DUK_HCOMPFUNC_SET_LEXENV(heap,h,v)  do { \
+#define DUK_HCOMPFUNC_GET_LEXENV(heap, h) ((h)->lex_env)
+#define DUK_HCOMPFUNC_SET_LEXENV(heap, h, v) \
+	do { \
 		(h)->lex_env = (v); \
 	} while (0)
-#define DUK_HCOMPFUNC_GET_VARENV(heap,h)  ((h)->var_env)
-#define DUK_HCOMPFUNC_SET_VARENV(heap,h,v)  do { \
+#define DUK_HCOMPFUNC_GET_VARENV(heap, h) ((h)->var_env)
+#define DUK_HCOMPFUNC_SET_VARENV(heap, h, v) \
+	do { \
 		(h)->var_env = (v); \
 	} while (0)
 #endif
@@ -7194,64 +7633,40 @@
  */
 
 /* Note: assumes 'data' is always a fixed buffer */
-#define DUK_HCOMPFUNC_GET_BUFFER_BASE(heap,h)  \
-	DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPFUNC_GET_DATA((heap), (h)))
+#define DUK_HCOMPFUNC_GET_BUFFER_BASE(heap, h) DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPFUNC_GET_DATA((heap), (h)))
 
-#define DUK_HCOMPFUNC_GET_CONSTS_BASE(heap,h)  \
-	((duk_tval *) (void *) DUK_HCOMPFUNC_GET_BUFFER_BASE((heap), (h)))
+#define DUK_HCOMPFUNC_GET_CONSTS_BASE(heap, h) ((duk_tval *) (void *) DUK_HCOMPFUNC_GET_BUFFER_BASE((heap), (h)))
 
-#define DUK_HCOMPFUNC_GET_FUNCS_BASE(heap,h)  \
-	DUK_HCOMPFUNC_GET_FUNCS((heap), (h))
+#define DUK_HCOMPFUNC_GET_FUNCS_BASE(heap, h) DUK_HCOMPFUNC_GET_FUNCS((heap), (h))
 
-#define DUK_HCOMPFUNC_GET_CODE_BASE(heap,h)  \
-	DUK_HCOMPFUNC_GET_BYTECODE((heap), (h))
+#define DUK_HCOMPFUNC_GET_CODE_BASE(heap, h) DUK_HCOMPFUNC_GET_BYTECODE((heap), (h))
 
-#define DUK_HCOMPFUNC_GET_CONSTS_END(heap,h)  \
-	((duk_tval *) (void *) DUK_HCOMPFUNC_GET_FUNCS((heap), (h)))
+#define DUK_HCOMPFUNC_GET_CONSTS_END(heap, h) ((duk_tval *) (void *) DUK_HCOMPFUNC_GET_FUNCS((heap), (h)))
 
-#define DUK_HCOMPFUNC_GET_FUNCS_END(heap,h)  \
-	((duk_hobject **) (void *) DUK_HCOMPFUNC_GET_BYTECODE((heap), (h)))
+#define DUK_HCOMPFUNC_GET_FUNCS_END(heap, h) ((duk_hobject **) (void *) DUK_HCOMPFUNC_GET_BYTECODE((heap), (h)))
 
 /* XXX: double evaluation of DUK_HCOMPFUNC_GET_DATA() */
-#define DUK_HCOMPFUNC_GET_CODE_END(heap,h)  \
+#define DUK_HCOMPFUNC_GET_CODE_END(heap, h) \
 	((duk_instr_t *) (void *) (DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), DUK_HCOMPFUNC_GET_DATA((heap), (h))) + \
-	                DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPFUNC_GET_DATA((heap), h))))
+	                           DUK_HBUFFER_GET_SIZE((duk_hbuffer *) DUK_HCOMPFUNC_GET_DATA((heap), h))))
 
-#define DUK_HCOMPFUNC_GET_CONSTS_SIZE(heap,h)  \
-	( \
-	 (duk_size_t) \
-	 ( \
-	   ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_CONSTS_END((heap), (h))) - \
-	   ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_CONSTS_BASE((heap), (h))) \
-	 ) \
-	)
+#define DUK_HCOMPFUNC_GET_CONSTS_SIZE(heap, h) \
+	((duk_size_t) (((const duk_uint8_t *) DUK_HCOMPFUNC_GET_CONSTS_END((heap), (h))) - \
+	               ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_CONSTS_BASE((heap), (h)))))
 
-#define DUK_HCOMPFUNC_GET_FUNCS_SIZE(heap,h)  \
-	( \
-	 (duk_size_t) \
-	 ( \
-	   ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_FUNCS_END((heap), (h))) - \
-	   ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_FUNCS_BASE((heap), (h))) \
-	 ) \
-	)
+#define DUK_HCOMPFUNC_GET_FUNCS_SIZE(heap, h) \
+	((duk_size_t) (((const duk_uint8_t *) DUK_HCOMPFUNC_GET_FUNCS_END((heap), (h))) - \
+	               ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_FUNCS_BASE((heap), (h)))))
 
-#define DUK_HCOMPFUNC_GET_CODE_SIZE(heap,h)  \
-	( \
-	 (duk_size_t) \
-	 ( \
-	   ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_CODE_END((heap),(h))) - \
-	   ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_CODE_BASE((heap),(h))) \
-	 ) \
-	)
+#define DUK_HCOMPFUNC_GET_CODE_SIZE(heap, h) \
+	((duk_size_t) (((const duk_uint8_t *) DUK_HCOMPFUNC_GET_CODE_END((heap), (h))) - \
+	               ((const duk_uint8_t *) DUK_HCOMPFUNC_GET_CODE_BASE((heap), (h)))))
 
-#define DUK_HCOMPFUNC_GET_CONSTS_COUNT(heap,h)  \
-	((duk_size_t) (DUK_HCOMPFUNC_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval)))
+#define DUK_HCOMPFUNC_GET_CONSTS_COUNT(heap, h) ((duk_size_t) (DUK_HCOMPFUNC_GET_CONSTS_SIZE((heap), (h)) / sizeof(duk_tval)))
 
-#define DUK_HCOMPFUNC_GET_FUNCS_COUNT(heap,h)  \
-	((duk_size_t) (DUK_HCOMPFUNC_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *)))
+#define DUK_HCOMPFUNC_GET_FUNCS_COUNT(heap, h) ((duk_size_t) (DUK_HCOMPFUNC_GET_FUNCS_SIZE((heap), (h)) / sizeof(duk_hobject *)))
 
-#define DUK_HCOMPFUNC_GET_CODE_COUNT(heap,h)  \
-	((duk_size_t) (DUK_HCOMPFUNC_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t)))
+#define DUK_HCOMPFUNC_GET_CODE_COUNT(heap, h) ((duk_size_t) (DUK_HCOMPFUNC_GET_CODE_SIZE((heap), (h)) / sizeof(duk_instr_t)))
 
 /*
  *  Validity assert
@@ -7259,9 +7674,14 @@
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hcompfunc_assert_valid(duk_hcompfunc *h);
-#define DUK_HCOMPFUNC_ASSERT_VALID(h)  do { duk_hcompfunc_assert_valid((h)); } while (0)
+#define DUK_HCOMPFUNC_ASSERT_VALID(h) \
+	do { \
+		duk_hcompfunc_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HCOMPFUNC_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HCOMPFUNC_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
 /*
@@ -7348,8 +7768,8 @@
 	 *  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 */
+	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
@@ -7396,7 +7816,7 @@
 #endif
 };
 
-#endif  /* DUK_HCOMPFUNC_H_INCLUDED */
+#endif /* DUK_HCOMPFUNC_H_INCLUDED */
 /* #include duk_hnatfunc.h */
 #line 1 "duk_hnatfunc.h"
 /*
@@ -7408,13 +7828,18 @@
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hnatfunc_assert_valid(duk_hnatfunc *h);
-#define DUK_HNATFUNC_ASSERT_VALID(h)  do { duk_hnatfunc_assert_valid((h)); } while (0)
+#define DUK_HNATFUNC_ASSERT_VALID(h) \
+	do { \
+		duk_hnatfunc_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HNATFUNC_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HNATFUNC_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
-#define DUK_HNATFUNC_NARGS_VARARGS  ((duk_int16_t) -1)
-#define DUK_HNATFUNC_NARGS_MAX      ((duk_int16_t) 0x7fff)
+#define DUK_HNATFUNC_NARGS_VARARGS ((duk_int16_t) -1)
+#define DUK_HNATFUNC_NARGS_MAX     ((duk_int16_t) 0x7fff)
 
 struct duk_hnatfunc {
 	/* shared object part */
@@ -7437,7 +7862,7 @@
 	 */
 };
 
-#endif  /* DUK_HNATFUNC_H_INCLUDED */
+#endif /* DUK_HNATFUNC_H_INCLUDED */
 /* #include duk_hboundfunc.h */
 #line 1 "duk_hboundfunc.h"
 /*
@@ -7454,9 +7879,14 @@
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hboundfunc_assert_valid(duk_hboundfunc *h);
-#define DUK_HBOUNDFUNC_ASSERT_VALID(h)  do { duk_hboundfunc_assert_valid((h)); } while (0)
+#define DUK_HBOUNDFUNC_ASSERT_VALID(h) \
+	do { \
+		duk_hboundfunc_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HBOUNDFUNC_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HBOUNDFUNC_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
 struct duk_hboundfunc {
@@ -7472,11 +7902,11 @@
 	duk_tval this_binding;
 
 	/* Arguments to prepend. */
-	duk_tval *args;  /* Separate allocation. */
+	duk_tval *args; /* Separate allocation. */
 	duk_idx_t nargs;
 };
 
-#endif  /* DUK_HBOUNDFUNC_H_INCLUDED */
+#endif /* DUK_HBOUNDFUNC_H_INCLUDED */
 /* #include duk_hbufobj.h */
 #line 1 "duk_hbufobj.h"
 /*
@@ -7489,31 +7919,37 @@
 #if defined(DUK_USE_BUFFEROBJECT_SUPPORT)
 
 /* All element accessors are host endian now (driven by TypedArray spec). */
-#define DUK_HBUFOBJ_ELEM_UINT8           0
-#define DUK_HBUFOBJ_ELEM_UINT8CLAMPED    1
-#define DUK_HBUFOBJ_ELEM_INT8            2
-#define DUK_HBUFOBJ_ELEM_UINT16          3
-#define DUK_HBUFOBJ_ELEM_INT16           4
-#define DUK_HBUFOBJ_ELEM_UINT32          5
-#define DUK_HBUFOBJ_ELEM_INT32           6
-#define DUK_HBUFOBJ_ELEM_FLOAT32         7
-#define DUK_HBUFOBJ_ELEM_FLOAT64         8
-#define DUK_HBUFOBJ_ELEM_MAX             8
+#define DUK_HBUFOBJ_ELEM_UINT8        0
+#define DUK_HBUFOBJ_ELEM_UINT8CLAMPED 1
+#define DUK_HBUFOBJ_ELEM_INT8         2
+#define DUK_HBUFOBJ_ELEM_UINT16       3
+#define DUK_HBUFOBJ_ELEM_INT16        4
+#define DUK_HBUFOBJ_ELEM_UINT32       5
+#define DUK_HBUFOBJ_ELEM_INT32        6
+#define DUK_HBUFOBJ_ELEM_FLOAT32      7
+#define DUK_HBUFOBJ_ELEM_FLOAT64      8
+#define DUK_HBUFOBJ_ELEM_MAX          8
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hbufobj_assert_valid(duk_hbufobj *h);
-#define DUK_HBUFOBJ_ASSERT_VALID(h)  do { duk_hbufobj_assert_valid((h)); } while (0)
+#define DUK_HBUFOBJ_ASSERT_VALID(h) \
+	do { \
+		duk_hbufobj_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HBUFOBJ_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HBUFOBJ_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
 /* Get the current data pointer (caller must ensure buf != NULL) as a
  * duk_uint8_t ptr.  Note that the result may be NULL if the underlying
  * buffer has zero size and is not a fixed buffer.
  */
-#define DUK_HBUFOBJ_GET_SLICE_BASE(heap,h) \
-	(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
-	(((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR((heap), (h)->buf)) + (h)->offset))
+#define DUK_HBUFOBJ_GET_SLICE_BASE(heap, h) \
+	(DUK_ASSERT_EXPR((h) != NULL), \
+	 DUK_ASSERT_EXPR((h)->buf != NULL), \
+	 (((duk_uint8_t *) DUK_HBUFFER_GET_DATA_PTR((heap), (h)->buf)) + (h)->offset))
 
 /* True if slice is full, i.e. offset is zero and length covers the entire
  * buffer.  This status may change independently of the duk_hbufobj if
@@ -7521,15 +7957,17 @@
  * being changed.
  */
 #define DUK_HBUFOBJ_FULL_SLICE(h) \
-	(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
-	((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf)))
+	(DUK_ASSERT_EXPR((h) != NULL), \
+	 DUK_ASSERT_EXPR((h)->buf != NULL), \
+	 ((h)->offset == 0 && (h)->length == DUK_HBUFFER_GET_SIZE((h)->buf)))
 
 /* Validate that the whole slice [0,length[ is contained in the underlying
  * buffer.  Caller must ensure 'buf' != NULL.
  */
 #define DUK_HBUFOBJ_VALID_SLICE(h) \
-	(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
-	((h)->offset + (h)->length <= DUK_HBUFFER_GET_SIZE((h)->buf)))
+	(DUK_ASSERT_EXPR((h) != NULL), \
+	 DUK_ASSERT_EXPR((h)->buf != NULL), \
+	 ((h)->offset + (h)->length <= DUK_HBUFFER_GET_SIZE((h)->buf)))
 
 /* Validate byte read/write for virtual 'offset', i.e. check that the
  * offset, taking into account h->offset, is within the underlying
@@ -7538,13 +7976,11 @@
  * behavior (e.g. if an underlying dynamic buffer changes after being
  * setup).  Caller must ensure 'buf' != NULL.
  */
-#define DUK_HBUFOBJ_VALID_BYTEOFFSET_INCL(h,off) \
-	(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
-	((h)->offset + (off) < DUK_HBUFFER_GET_SIZE((h)->buf)))
+#define DUK_HBUFOBJ_VALID_BYTEOFFSET_INCL(h, off) \
+	(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), ((h)->offset + (off) < DUK_HBUFFER_GET_SIZE((h)->buf)))
 
-#define DUK_HBUFOBJ_VALID_BYTEOFFSET_EXCL(h,off) \
-	(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), \
-	((h)->offset + (off) <= DUK_HBUFFER_GET_SIZE((h)->buf)))
+#define DUK_HBUFOBJ_VALID_BYTEOFFSET_EXCL(h, off) \
+	(DUK_ASSERT_EXPR((h) != NULL), DUK_ASSERT_EXPR((h)->buf != NULL), ((h)->offset + (off) <= DUK_HBUFFER_GET_SIZE((h)->buf)))
 
 /* Clamp an input byte length (already assumed to be within the nominal
  * duk_hbufobj 'length') to the current dynamic buffer limits to yield
@@ -7552,12 +7988,10 @@
  * be invalidated by any side effect because it may trigger a user
  * callback that resizes the underlying buffer.
  */
-#define DUK_HBUFOBJ_CLAMP_BYTELENGTH(h,len) \
-	(DUK_ASSERT_EXPR((h) != NULL), \
-	duk_hbufobj_clamp_bytelength((h), (len)))
+#define DUK_HBUFOBJ_CLAMP_BYTELENGTH(h, len) (DUK_ASSERT_EXPR((h) != NULL), duk_hbufobj_clamp_bytelength((h), (len)))
 
 /* Typed arrays have virtual indices, ArrayBuffer and DataView do not. */
-#define DUK_HBUFOBJ_HAS_VIRTUAL_INDICES(h)  ((h)->is_typedarray)
+#define DUK_HBUFOBJ_HAS_VIRTUAL_INDICES(h) ((h)->is_typedarray)
 
 struct duk_hbufobj {
 	/* Shared object part. */
@@ -7582,30 +8016,36 @@
 	 * be dynamic and its pointer unstable.
 	 */
 
-	duk_uint_t offset;       /* byte offset to buf */
-	duk_uint_t length;       /* byte index limit for element access, exclusive */
-	duk_uint8_t shift;       /* element size shift:
-	                          *   0 = u8/i8
-	                          *   1 = u16/i16
-	                          *   2 = u32/i32/float
-	                          *   3 = double
-	                          */
-	duk_uint8_t elem_type;   /* element type */
+	duk_uint_t offset; /* byte offset to buf */
+	duk_uint_t length; /* byte index limit for element access, exclusive */
+	duk_uint8_t shift; /* element size shift:
+	                    *   0 = u8/i8
+	                    *   1 = u16/i16
+	                    *   2 = u32/i32/float
+	                    *   3 = double
+	                    */
+	duk_uint8_t elem_type; /* element type */
 	duk_uint8_t is_typedarray;
 };
 
 DUK_INTERNAL_DECL duk_uint_t duk_hbufobj_clamp_bytelength(duk_hbufobj *h_bufobj, duk_uint_t len);
 DUK_INTERNAL_DECL void duk_hbufobj_push_uint8array_from_plain(duk_hthread *thr, duk_hbuffer *h_buf);
-DUK_INTERNAL_DECL void duk_hbufobj_push_validated_read(duk_hthread *thr, duk_hbufobj *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size);
-DUK_INTERNAL_DECL void duk_hbufobj_validated_write(duk_hthread *thr, duk_hbufobj *h_bufobj, duk_uint8_t *p, duk_small_uint_t elem_size);
+DUK_INTERNAL_DECL void duk_hbufobj_push_validated_read(duk_hthread *thr,
+                                                       duk_hbufobj *h_bufobj,
+                                                       duk_uint8_t *p,
+                                                       duk_small_uint_t elem_size);
+DUK_INTERNAL_DECL void duk_hbufobj_validated_write(duk_hthread *thr,
+                                                   duk_hbufobj *h_bufobj,
+                                                   duk_uint8_t *p,
+                                                   duk_small_uint_t elem_size);
 DUK_INTERNAL_DECL void duk_hbufobj_promote_plain(duk_hthread *thr, duk_idx_t idx);
 
-#else  /* DUK_USE_BUFFEROBJECT_SUPPORT */
+#else /* DUK_USE_BUFFEROBJECT_SUPPORT */
 
 /* nothing */
 
-#endif  /* DUK_USE_BUFFEROBJECT_SUPPORT */
-#endif  /* DUK_HBUFOBJ_H_INCLUDED */
+#endif /* DUK_USE_BUFFEROBJECT_SUPPORT */
+#endif /* DUK_HBUFOBJ_H_INCLUDED */
 /* #include duk_hthread.h */
 #line 1 "duk_hthread.h"
 /*
@@ -7624,38 +8064,38 @@
  */
 
 /* Initial valstack size, roughly 0.7kiB. */
-#define DUK_VALSTACK_INITIAL_SIZE       96U
+#define DUK_VALSTACK_INITIAL_SIZE 96U
 
 /* Internal extra elements assumed on function entry, always added to
  * user-defined 'extra' for e.g. the duk_check_stack() call.
  */
-#define DUK_VALSTACK_INTERNAL_EXTRA     32U
+#define DUK_VALSTACK_INTERNAL_EXTRA 32U
 
 /* Number of elements guaranteed to be user accessible (in addition to call
  * arguments) on Duktape/C function entry.  This is the major public API
  * commitment.
  */
-#define DUK_VALSTACK_API_ENTRY_MINIMUM  DUK_API_ENTRY_STACK
+#define DUK_VALSTACK_API_ENTRY_MINIMUM DUK_API_ENTRY_STACK
 
 /*
  *  Activation defines
  */
 
-#define DUK_ACT_FLAG_STRICT             (1U << 0)  /* function executes in strict mode */
-#define DUK_ACT_FLAG_TAILCALLED         (1U << 1)  /* activation has tail called one or more times */
-#define DUK_ACT_FLAG_CONSTRUCT          (1U << 2)  /* function executes as a constructor (called via "new") */
-#define DUK_ACT_FLAG_PREVENT_YIELD      (1U << 3)  /* activation prevents yield (native call or "new") */
-#define DUK_ACT_FLAG_DIRECT_EVAL        (1U << 4)  /* activation is a direct eval call */
-#define DUK_ACT_FLAG_CONSTRUCT_PROXY    (1U << 5)  /* activation is for Proxy 'construct' call, special return value handling */
-#define DUK_ACT_FLAG_BREAKPOINT_ACTIVE  (1U << 6)  /* activation has active breakpoint(s) */
+#define DUK_ACT_FLAG_STRICT            (1U << 0) /* function executes in strict mode */
+#define DUK_ACT_FLAG_TAILCALLED        (1U << 1) /* activation has tail called one or more times */
+#define DUK_ACT_FLAG_CONSTRUCT         (1U << 2) /* function executes as a constructor (called via "new") */
+#define DUK_ACT_FLAG_PREVENT_YIELD     (1U << 3) /* activation prevents yield (native call or "new") */
+#define DUK_ACT_FLAG_DIRECT_EVAL       (1U << 4) /* activation is a direct eval call */
+#define DUK_ACT_FLAG_CONSTRUCT_PROXY   (1U << 5) /* activation is for Proxy 'construct' call, special return value handling */
+#define DUK_ACT_FLAG_BREAKPOINT_ACTIVE (1U << 6) /* activation has active breakpoint(s) */
 
-#define DUK_ACT_GET_FUNC(act)           ((act)->func)
+#define DUK_ACT_GET_FUNC(act) ((act)->func)
 
 /*
  *  Flags for __FILE__ / __LINE__ registered into tracedata
  */
 
-#define DUK_TB_FLAG_NOBLAME_FILELINE    (1U << 0)  /* don't report __FILE__ / __LINE__ as fileName/lineNumber */
+#define DUK_TB_FLAG_NOBLAME_FILELINE (1U << 0) /* don't report __FILE__ / __LINE__ as fileName/lineNumber */
 
 /*
  *  Catcher defines
@@ -7664,52 +8104,60 @@
 /* XXX: remove catcher type entirely */
 
 /* 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_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          (1U << 4)   /* catch part will catch */
-#define DUK_CAT_FLAG_FINALLY_ENABLED        (1U << 5)   /* finally part will catch */
-#define DUK_CAT_FLAG_CATCH_BINDING_ENABLED  (1U << 6)   /* request to create catch binding */
-#define DUK_CAT_FLAG_LEXENV_ACTIVE          (1U << 7)   /* catch or with binding is currently active */
+#define DUK_CAT_FLAG_CATCH_ENABLED         (1U << 4) /* catch part will catch */
+#define DUK_CAT_FLAG_FINALLY_ENABLED       (1U << 5) /* finally part will catch */
+#define DUK_CAT_FLAG_CATCH_BINDING_ENABLED (1U << 6) /* request to create catch binding */
+#define DUK_CAT_FLAG_LEXENV_ACTIVE         (1U << 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_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_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_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 { \
+#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 { \
+#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 { \
+#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 { \
+#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 { \
+#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 { \
+#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 { \
+#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 { \
+#define DUK_CAT_CLEAR_LEXENV_ACTIVE(c) \
+	do { \
 		(c)->flags &= ~DUK_CAT_FLAG_LEXENV_ACTIVE; \
 	} while (0)
 
@@ -7718,24 +8166,21 @@
  */
 
 #if defined(DUK_USE_ROM_STRINGS)
-#define DUK_HTHREAD_GET_STRING(thr,idx) \
-	((duk_hstring *) DUK_LOSE_CONST(duk_rom_strings_stridx[(idx)]))
-#else  /* DUK_USE_ROM_STRINGS */
+#define DUK_HTHREAD_GET_STRING(thr, idx) ((duk_hstring *) DUK_LOSE_CONST(duk_rom_strings_stridx[(idx)]))
+#else /* DUK_USE_ROM_STRINGS */
 #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)]))
+#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)])
+#define DUK_HTHREAD_GET_STRING(thr, idx) ((thr)->strs[(idx)])
 #endif
-#endif  /* DUK_USE_ROM_STRINGS */
+#endif /* DUK_USE_ROM_STRINGS */
 
 /* 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 */
+#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 */
 
 /* Executor interrupt default interval when nothing else requires a
  * smaller value.  The default interval must be small enough to allow
@@ -7743,7 +8188,7 @@
  * impact on execution performance low.
  */
 #if defined(DUK_USE_INTERRUPT_COUNTER)
-#define DUK_HTHREAD_INTCTR_DEFAULT     (256L * 1024L)
+#define DUK_HTHREAD_INTCTR_DEFAULT (256L * 1024L)
 #endif
 
 /*
@@ -7757,20 +8202,31 @@
 #if defined(DUK_USE_ASSERTIONS)
 /* Assertions for internals. */
 DUK_INTERNAL_DECL void duk_hthread_assert_valid(duk_hthread *thr);
-#define DUK_HTHREAD_ASSERT_VALID(thr)  do { duk_hthread_assert_valid((thr)); } while (0)
+#define DUK_HTHREAD_ASSERT_VALID(thr) \
+	do { \
+		duk_hthread_assert_valid((thr)); \
+	} while (0)
 
 /* Assertions for public API calls; a bit stronger. */
 DUK_INTERNAL_DECL void duk_ctx_assert_valid(duk_hthread *thr);
-#define DUK_CTX_ASSERT_VALID(thr)  do { duk_ctx_assert_valid((thr)); } while (0)
+#define DUK_CTX_ASSERT_VALID(thr) \
+	do { \
+		duk_ctx_assert_valid((thr)); \
+	} while (0)
 #else
-#define DUK_HTHREAD_ASSERT_VALID(thr)  do {} while (0)
-#define DUK_CTX_ASSERT_VALID(thr)  do {} while (0)
+#define DUK_HTHREAD_ASSERT_VALID(thr) \
+	do { \
+	} while (0)
+#define DUK_CTX_ASSERT_VALID(thr) \
+	do { \
+	} while (0)
 #endif
 
 /* Assertions for API call entry specifically.  Checks 'ctx' but also may
  * check internal state (e.g. not in a debugger transport callback).
  */
-#define DUK_ASSERT_API_ENTRY(thr) do { \
+#define DUK_ASSERT_API_ENTRY(thr) \
+	do { \
 		DUK_CTX_ASSERT_VALID((thr)); \
 		DUK_ASSERT((thr)->heap != NULL); \
 		DUK_ASSERT((thr)->heap->dbg_calling_transport == 0); \
@@ -7780,11 +8236,9 @@
  *  Assertion helpers.
  */
 
-#define DUK_ASSERT_STRIDX_VALID(val) \
-	DUK_ASSERT((duk_uint_t) (val) < DUK_HEAP_NUM_STRINGS)
+#define DUK_ASSERT_STRIDX_VALID(val) DUK_ASSERT((duk_uint_t) (val) < DUK_HEAP_NUM_STRINGS)
 
-#define DUK_ASSERT_BIDX_VALID(val) \
-	DUK_ASSERT((duk_uint_t) (val) < DUK_NUM_BUILTINS)
+#define DUK_ASSERT_BIDX_VALID(val) DUK_ASSERT((duk_uint_t) (val) < DUK_NUM_BUILTINS)
 
 /*
  *  Misc
@@ -7792,9 +8246,7 @@
 
 /* Fast access to 'this' binding.  Assumes there's a call in progress. */
 #define DUK_HTHREAD_THIS_PTR(thr) \
-	(DUK_ASSERT_EXPR((thr) != NULL), \
-	 DUK_ASSERT_EXPR((thr)->valstack_bottom > (thr)->valstack), \
-	 (thr)->valstack_bottom - 1)
+	(DUK_ASSERT_EXPR((thr) != NULL), DUK_ASSERT_EXPR((thr)->valstack_bottom > (thr)->valstack), (thr)->valstack_bottom - 1)
 
 /*
  *  Struct defines
@@ -7802,12 +8254,13 @@
 
 /* Fields are ordered for alignment/packing. */
 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_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_activation *parent; /* previous (parent) activation (or NULL if none) */
-	duk_hobject *var_env;   /* current variable environment (may be NULL if delayed) */
-	duk_hobject *lex_env;   /* current lexical environment (may be NULL if delayed) */
-	duk_catcher *cat;       /* current catcher (or NULL) */
+	duk_hobject *var_env; /* current variable environment (may be NULL if delayed) */
+	duk_hobject *lex_env; /* current lexical environment (may be NULL if delayed) */
+	duk_catcher *cat; /* current catcher (or NULL) */
 
 #if defined(DUK_USE_NONSTD_FUNC_CALLER_PROPERTY)
 	/* Previous value of 'func' caller, restored when unwound.  Only in use
@@ -7816,7 +8269,7 @@
 	duk_hobject *prev_caller;
 #endif
 
-	duk_instr_t *curr_pc;   /* next instruction to execute (points to 'func' bytecode, stable pointer), NULL for native calls */
+	duk_instr_t *curr_pc; /* next instruction to execute (points to 'func' bytecode, stable pointer), NULL for native calls */
 
 	/* bottom_byteoff and retval_byteoff are only used for book-keeping
 	 * of ECMAScript-initiated calls, to allow returning to an ECMAScript
@@ -7863,12 +8316,12 @@
 };
 
 struct duk_catcher {
-	duk_catcher *parent;            /* previous (parent) catcher (or NULL if none) */
-	duk_hstring *h_varname;         /* borrowed reference to catch variable name (or NULL if none) */
-	                                /* (reference is valid as long activation exists) */
-	duk_instr_t *pc_base;           /* resume execution from pc_base or pc_base+1 (points to 'func' bytecode, stable pointer) */
-	duk_size_t idx_base;            /* idx_base and idx_base+1 get completion value and type */
-	duk_uint32_t flags;             /* type and control flags, label number */
+	duk_catcher *parent; /* previous (parent) catcher (or NULL if none) */
+	duk_hstring *h_varname; /* borrowed reference to catch variable name (or NULL if none) */
+	/* (reference is valid as long activation exists) */
+	duk_instr_t *pc_base; /* resume execution from pc_base or pc_base+1 (points to 'func' bytecode, stable pointer) */
+	duk_size_t idx_base; /* idx_base and idx_base+1 get completion value and type */
+	duk_uint32_t flags; /* type and control flags, label number */
 	/* XXX: could pack 'flags' and 'idx_base' to same value in practice,
 	 * on 32-bit targets this would make duk_catcher 16 bytes.
 	 */
@@ -7926,21 +8379,21 @@
 	 *     yyy = arbitrary values, inside current frame
 	 *     uuu = outside active value stack, initialized to 'undefined'
 	 */
-	duk_tval *valstack;                     /* start of valstack allocation */
-	duk_tval *valstack_end;                 /* end of valstack reservation/guarantee (exclusive) */
-	duk_tval *valstack_alloc_end;           /* end of valstack allocation */
-	duk_tval *valstack_bottom;              /* bottom of current frame */
-	duk_tval *valstack_top;                 /* top of current frame (exclusive) */
+	duk_tval *valstack; /* start of valstack allocation */
+	duk_tval *valstack_end; /* end of valstack reservation/guarantee (exclusive) */
+	duk_tval *valstack_alloc_end; /* end of valstack allocation */
+	duk_tval *valstack_bottom; /* bottom of current frame */
+	duk_tval *valstack_top; /* top of current frame (exclusive) */
 
 	/* Call stack, represented as a linked list starting from the current
 	 * activation (or NULL if nothing is active).
 	 */
-	duk_activation *callstack_curr;         /* current activation (or NULL if none) */
-	duk_size_t callstack_top;               /* number of activation records in callstack (0 if none) */
-	duk_size_t callstack_preventcount;      /* number of activation records in callstack preventing a yield */
+	duk_activation *callstack_curr; /* current activation (or NULL if none) */
+	duk_size_t callstack_top; /* number of activation records in callstack (0 if none) */
+	duk_size_t callstack_preventcount; /* number of activation records in callstack preventing a yield */
 
 	/* Yield/resume book-keeping. */
-	duk_hthread *resumer;                   /* who resumed us (if any) */
+	duk_hthread *resumer; /* who resumed us (if any) */
 
 	/* Current compiler state (if any), used for augmenting SyntaxErrors. */
 	duk_compiler_ctx *compile_ctx;
@@ -7953,8 +8406,8 @@
 	 * important for the counter to be conveniently accessible for the
 	 * bytecode executor inner loop for performance reasons.
 	 */
-	duk_int_t interrupt_counter;    /* countdown state */
-	duk_int_t interrupt_init;       /* start value for current countdown */
+	duk_int_t interrupt_counter; /* countdown state */
+	duk_int_t interrupt_init; /* start value for current countdown */
 #endif
 
 	/* Builtin-objects; may or may not be shared with other threads,
@@ -8006,7 +8459,7 @@
 DUK_INTERNAL_DECL void duk_hthread_valstack_torture_realloc(duk_hthread *thr);
 #endif
 
-DUK_INTERNAL_DECL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud);  /* indirect allocs */
+DUK_INTERNAL_DECL void *duk_hthread_get_valstack_ptr(duk_heap *heap, void *ud); /* indirect allocs */
 
 #if defined(DUK_USE_DEBUGGER_SUPPORT)
 DUK_INTERNAL_DECL duk_uint_fast32_t duk_hthread_get_act_curr_pc(duk_hthread *thr, duk_activation *act);
@@ -8015,7 +8468,7 @@
 DUK_INTERNAL_DECL void duk_hthread_sync_currpc(duk_hthread *thr);
 DUK_INTERNAL_DECL void duk_hthread_sync_and_null_currpc(duk_hthread *thr);
 
-#endif  /* DUK_HTHREAD_H_INCLUDED */
+#endif /* DUK_HTHREAD_H_INCLUDED */
 /* #include duk_harray.h */
 #line 1 "duk_harray.h"
 /*
@@ -8031,15 +8484,26 @@
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_harray_assert_valid(duk_harray *h);
-#define DUK_HARRAY_ASSERT_VALID(h)  do { duk_harray_assert_valid((h)); } while (0)
+#define DUK_HARRAY_ASSERT_VALID(h) \
+	do { \
+		duk_harray_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HARRAY_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HARRAY_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
-#define DUK_HARRAY_LENGTH_WRITABLE(h)         (!(h)->length_nonwritable)
-#define DUK_HARRAY_LENGTH_NONWRITABLE(h)      ((h)->length_nonwritable)
-#define DUK_HARRAY_SET_LENGTH_WRITABLE(h)     do { (h)->length_nonwritable = 0; } while (0)
-#define DUK_HARRAY_SET_LENGTH_NONWRITABLE(h)  do { (h)->length_nonwritable = 1; } while (0)
+#define DUK_HARRAY_LENGTH_WRITABLE(h)    (!(h)->length_nonwritable)
+#define DUK_HARRAY_LENGTH_NONWRITABLE(h) ((h)->length_nonwritable)
+#define DUK_HARRAY_SET_LENGTH_WRITABLE(h) \
+	do { \
+		(h)->length_nonwritable = 0; \
+	} while (0)
+#define DUK_HARRAY_SET_LENGTH_NONWRITABLE(h) \
+	do { \
+		(h)->length_nonwritable = 1; \
+	} while (0)
 
 struct duk_harray {
 	/* Shared object part. */
@@ -8065,7 +8529,7 @@
 	duk_bool_t length_nonwritable;
 };
 
-#endif  /* DUK_HARRAY_H_INCLUDED */
+#endif /* DUK_HARRAY_H_INCLUDED */
 /* #include duk_henv.h */
 #line 1 "duk_henv.h"
 /*
@@ -8078,11 +8542,21 @@
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hdecenv_assert_valid(duk_hdecenv *h);
 DUK_INTERNAL_DECL void duk_hobjenv_assert_valid(duk_hobjenv *h);
-#define DUK_HDECENV_ASSERT_VALID(h)  do { duk_hdecenv_assert_valid((h)); } while (0)
-#define DUK_HOBJENV_ASSERT_VALID(h)  do { duk_hobjenv_assert_valid((h)); } while (0)
+#define DUK_HDECENV_ASSERT_VALID(h) \
+	do { \
+		duk_hdecenv_assert_valid((h)); \
+	} while (0)
+#define DUK_HOBJENV_ASSERT_VALID(h) \
+	do { \
+		duk_hobjenv_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HDECENV_ASSERT_VALID(h)  do {} while (0)
-#define DUK_HOBJENV_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HDECENV_ASSERT_VALID(h) \
+	do { \
+	} while (0)
+#define DUK_HOBJENV_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
 struct duk_hdecenv {
@@ -8112,7 +8586,7 @@
 	duk_bool_t has_this;
 };
 
-#endif  /* DUK_HENV_H_INCLUDED */
+#endif /* DUK_HENV_H_INCLUDED */
 /* #include duk_hbuffer.h */
 #line 1 "duk_hbuffer.h"
 /*
@@ -8137,17 +8611,17 @@
  *  External buffer:  DUK_HBUFFER_FLAG_DYNAMIC | DUK_HBUFFER_FLAG_EXTERNAL
  */
 
-#define DUK_HBUFFER_FLAG_DYNAMIC                  DUK_HEAPHDR_USER_FLAG(0)    /* buffer is behind a pointer, dynamic or external */
-#define DUK_HBUFFER_FLAG_EXTERNAL                 DUK_HEAPHDR_USER_FLAG(1)    /* buffer pointer is to an externally allocated buffer */
+#define DUK_HBUFFER_FLAG_DYNAMIC  DUK_HEAPHDR_USER_FLAG(0) /* buffer is behind a pointer, dynamic or external */
+#define DUK_HBUFFER_FLAG_EXTERNAL DUK_HEAPHDR_USER_FLAG(1) /* buffer pointer is to an externally allocated buffer */
 
-#define DUK_HBUFFER_HAS_DYNAMIC(x)                DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-#define DUK_HBUFFER_HAS_EXTERNAL(x)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
+#define DUK_HBUFFER_HAS_DYNAMIC(x)  DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
+#define DUK_HBUFFER_HAS_EXTERNAL(x) DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
 
-#define DUK_HBUFFER_SET_DYNAMIC(x)                DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-#define DUK_HBUFFER_SET_EXTERNAL(x)               DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
+#define DUK_HBUFFER_SET_DYNAMIC(x)  DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
+#define DUK_HBUFFER_SET_EXTERNAL(x) DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
 
-#define DUK_HBUFFER_CLEAR_DYNAMIC(x)              DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
-#define DUK_HBUFFER_CLEAR_EXTERNAL(x)             DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
+#define DUK_HBUFFER_CLEAR_DYNAMIC(x)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_DYNAMIC)
+#define DUK_HBUFFER_CLEAR_EXTERNAL(x) DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HBUFFER_FLAG_EXTERNAL)
 
 /*
  *  Misc defines
@@ -8160,12 +8634,12 @@
  */
 
 #if defined(DUK_USE_BUFLEN16)
-#define DUK_HBUFFER_MAX_BYTELEN                   (0x0000ffffUL)
+#define DUK_HBUFFER_MAX_BYTELEN (0x0000ffffUL)
 #else
 /* Intentionally not 0x7fffffffUL; at least JSON code expects that
  * 2*len + 2 fits in 32 bits.
  */
-#define DUK_HBUFFER_MAX_BYTELEN                   (0x7ffffffeUL)
+#define DUK_HBUFFER_MAX_BYTELEN (0x7ffffffeUL)
 #endif
 
 /*
@@ -8174,60 +8648,70 @@
 
 #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 { \
+#define DUK_HBUFFER_GET_SIZE(x) ((x)->hdr.h_flags >> 16)
+#define DUK_HBUFFER_SET_SIZE(x, v) \
+	do { \
 		duk_size_t duk__v; \
 		duk__v = (v); \
 		DUK_ASSERT(duk__v <= 0xffffUL); \
 		(x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | (((duk_uint32_t) duk__v) << 16); \
 	} while (0)
-#define DUK_HBUFFER_ADD_SIZE(x,dv)  do { \
+#define DUK_HBUFFER_ADD_SIZE(x, dv) \
+	do { \
 		(x)->hdr.h_flags += ((dv) << 16); \
 	} while (0)
-#define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
+#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 { \
+#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 { \
+#define DUK_HBUFFER_ADD_SIZE(x, dv) \
+	do { \
 		(x)->size += (dv); \
 	} while (0)
-#define DUK_HBUFFER_SUB_SIZE(x,dv)  do { \
+#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_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))
+#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))
 
 #define DUK_HBUFFER_EXTERNAL_GET_SIZE(x)    DUK_HBUFFER_GET_SIZE((duk_hbuffer *) (x))
-#define DUK_HBUFFER_EXTERNAL_SET_SIZE(x,v)  DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
+#define DUK_HBUFFER_EXTERNAL_SET_SIZE(x, v) DUK_HBUFFER_SET_SIZE((duk_hbuffer *) (x), (v))
 
-#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap,x)    ((duk_uint8_t *) (((duk_hbuffer_fixed *) (void *) (x)) + 1))
+#define DUK_HBUFFER_FIXED_GET_DATA_PTR(heap, x) ((duk_uint8_t *) (((duk_hbuffer_fixed *) (void *) (x)) + 1))
 
 #if defined(DUK_USE_HEAPPTR16)
-#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap,x) \
+#define DUK_HBUFFER_DYNAMIC_GET_DATA_PTR(heap, x) \
 	((void *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, ((duk_heaphdr *) (x))->h_extra16))
-#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap,x,v)     do { \
+#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR(heap, x, v) \
+	do { \
 		((duk_heaphdr *) (x))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (v)); \
 	} while (0)
-#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap,x)  do { \
-		((duk_heaphdr *) (x))->h_extra16 = 0;  /* assume 0 <=> NULL */ \
+#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap, x) \
+	do { \
+		((duk_heaphdr *) (x))->h_extra16 = 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 { \
+#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 { \
+#define DUK_HBUFFER_DYNAMIC_SET_DATA_PTR_NULL(heap, x) \
+	do { \
 		(x)->curr_alloc = (void *) NULL; \
 	} while (0)
 #endif
@@ -8236,21 +8720,23 @@
  * Duktape heap.
  */
 #if defined(DUK_USE_HEAPPTR16)
-#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \
-	((void *) (x)->curr_alloc)
-#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v)     do { \
+#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, x) ((void *) (x)->curr_alloc)
+#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, x, v) \
+	do { \
 		(x)->curr_alloc = (void *) (v); \
 	} while (0)
-#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x)  do { \
+#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap, x) \
+	do { \
 		(x)->curr_alloc = (void *) NULL; \
 	} while (0)
 #else
-#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap,x) \
-	((void *) (x)->curr_alloc)
-#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap,x,v)     do { \
+#define DUK_HBUFFER_EXTERNAL_GET_DATA_PTR(heap, x) ((void *) (x)->curr_alloc)
+#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR(heap, x, v) \
+	do { \
 		(x)->curr_alloc = (void *) (v); \
 	} while (0)
-#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap,x)  do { \
+#define DUK_HBUFFER_EXTERNAL_SET_DATA_PTR_NULL(heap, x) \
+	do { \
 		(x)->curr_alloc = (void *) NULL; \
 	} while (0)
 #endif
@@ -8259,32 +8745,31 @@
  * size).  May be NULL for zero size dynamic/external buffer.
  */
 #if defined(DUK_USE_HEAPPTR16)
-#define DUK_HBUFFER_GET_DATA_PTR(heap,x)  ( \
-	DUK_HBUFFER_HAS_DYNAMIC((x)) ? \
-		( \
-			DUK_HBUFFER_HAS_EXTERNAL((x)) ? \
-				DUK_HBUFFER_EXTERNAL_GET_DATA_PTR((heap), (duk_hbuffer_external *) (x)) : \
-				DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x)) \
-		) : \
-		DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (void *) (x)) \
-	)
+#define DUK_HBUFFER_GET_DATA_PTR(heap, x) \
+	(DUK_HBUFFER_HAS_DYNAMIC((x)) ? \
+             (DUK_HBUFFER_HAS_EXTERNAL((x)) ? DUK_HBUFFER_EXTERNAL_GET_DATA_PTR((heap), (duk_hbuffer_external *) (x)) : \
+                                              DUK_HBUFFER_DYNAMIC_GET_DATA_PTR((heap), (duk_hbuffer_dynamic *) (x))) : \
+             DUK_HBUFFER_FIXED_GET_DATA_PTR((heap), (duk_hbuffer_fixed *) (void *) (x)))
 #else
 /* Without heap pointer compression duk_hbuffer_dynamic and duk_hbuffer_external
  * have the same layout so checking for fixed vs. dynamic (or external) is enough.
  */
-#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 *) (void *) (x)) \
-	)
+#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 *) (void *) (x)))
 #endif
 
 /* Validity assert. */
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hbuffer_assert_valid(duk_hbuffer *h);
-#define DUK_HBUFFER_ASSERT_VALID(h)  do { duk_hbuffer_assert_valid((h)); } while (0)
+#define DUK_HBUFFER_ASSERT_VALID(h) \
+	do { \
+		duk_hbuffer_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HBUFFER_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HBUFFER_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
 /*
@@ -8382,9 +8867,9 @@
 	 */
 }
 #if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_GCC_ATTR)
-__attribute__ ((aligned (8)))
+__attribute__((aligned(8)))
 #elif (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_CLANG_ATTR)
-__attribute__ ((aligned (8)))
+__attribute__((aligned(8)))
 #endif
 ;
 #if (DUK_USE_ALIGN_BY == 8) && defined(DUK_USE_PACK_MSVC_PRAGMA)
@@ -8407,7 +8892,7 @@
 #if defined(DUK_USE_HEAPPTR16)
 	/* Stored in duk_heaphdr h_extra16. */
 #else
-	void *curr_alloc;  /* may be NULL if alloc_size == 0 */
+	void *curr_alloc; /* may be NULL if alloc_size == 0 */
 #endif
 
 	/*
@@ -8436,7 +8921,7 @@
 	/* Cannot be compressed as a heap pointer because may point to
 	 * an arbitrary address.
 	 */
-	void *curr_alloc;  /* may be NULL if alloc_size == 0 */
+	void *curr_alloc; /* may be NULL if alloc_size == 0 */
 };
 
 /*
@@ -8444,13 +8929,13 @@
  */
 
 DUK_INTERNAL_DECL duk_hbuffer *duk_hbuffer_alloc(duk_heap *heap, duk_size_t size, duk_small_uint_t flags, void **out_bufdata);
-DUK_INTERNAL_DECL void *duk_hbuffer_get_dynalloc_ptr(duk_heap *heap, void *ud);  /* indirect allocs */
+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_INTERNAL_DECL void duk_hbuffer_reset(duk_hthread *thr, duk_hbuffer_dynamic *buf);
 
-#endif  /* DUK_HBUFFER_H_INCLUDED */
+#endif /* DUK_HBUFFER_H_INCLUDED */
 /* #include duk_hproxy.h */
 #line 1 "duk_hproxy.h"
 /*
@@ -8462,9 +8947,14 @@
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_hproxy_assert_valid(duk_hproxy *h);
-#define DUK_HPROXY_ASSERT_VALID(h)  do { duk_hproxy_assert_valid((h)); } while (0)
+#define DUK_HPROXY_ASSERT_VALID(h) \
+	do { \
+		duk_hproxy_assert_valid((h)); \
+	} while (0)
 #else
-#define DUK_HPROXY_ASSERT_VALID(h)  do {} while (0)
+#define DUK_HPROXY_ASSERT_VALID(h) \
+	do { \
+	} while (0)
 #endif
 
 struct duk_hproxy {
@@ -8478,7 +8968,7 @@
 	duk_hobject *handler;
 };
 
-#endif  /* DUK_HPROXY_H_INCLUDED */
+#endif /* DUK_HPROXY_H_INCLUDED */
 /* #include duk_heap.h */
 #line 1 "duk_heap.h"
 /*
@@ -8497,46 +8987,50 @@
  *  Heap flags
  */
 
-#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED            (1U << 0)  /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */
-#define DUK_HEAP_FLAG_INTERRUPT_RUNNING                        (1U << 1)  /* executor interrupt running (used to avoid nested interrupts) */
-#define DUK_HEAP_FLAG_FINALIZER_NORESCUE                       (1U << 2)  /* heap destruction ongoing, finalizer rescue no longer possible */
-#define DUK_HEAP_FLAG_DEBUGGER_PAUSED                          (1U << 3)  /* debugger is paused: talk with debug client until step/resume */
+#define DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED \
+	(1U << 0) /* mark-and-sweep marking reached a recursion limit and must use multi-pass marking */
+#define DUK_HEAP_FLAG_INTERRUPT_RUNNING  (1U << 1) /* executor interrupt running (used to avoid nested interrupts) */
+#define DUK_HEAP_FLAG_FINALIZER_NORESCUE (1U << 2) /* heap destruction ongoing, finalizer rescue no longer possible */
+#define DUK_HEAP_FLAG_DEBUGGER_PAUSED    (1U << 3) /* debugger is paused: talk with debug client until step/resume */
 
-#define DUK__HEAP_HAS_FLAGS(heap,bits)               ((heap)->flags & (bits))
-#define DUK__HEAP_SET_FLAGS(heap,bits)  do { \
+#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 { \
+#define DUK__HEAP_CLEAR_FLAGS(heap, bits) \
+	do { \
 		(heap)->flags &= ~(bits); \
 	} while (0)
 
-#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
-#define DUK_HEAP_HAS_INTERRUPT_RUNNING(heap)               DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
-#define DUK_HEAP_HAS_FINALIZER_NORESCUE(heap)              DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
-#define DUK_HEAP_HAS_DEBUGGER_PAUSED(heap)                 DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
+#define DUK_HEAP_HAS_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
+#define DUK_HEAP_HAS_INTERRUPT_RUNNING(heap)             DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
+#define DUK_HEAP_HAS_FINALIZER_NORESCUE(heap)            DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
+#define DUK_HEAP_HAS_DEBUGGER_PAUSED(heap)               DUK__HEAP_HAS_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
 
-#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap)   DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
-#define DUK_HEAP_SET_INTERRUPT_RUNNING(heap)               DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
-#define DUK_HEAP_SET_FINALIZER_NORESCUE(heap)              DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
-#define DUK_HEAP_SET_DEBUGGER_PAUSED(heap)                 DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
+#define DUK_HEAP_SET_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
+#define DUK_HEAP_SET_INTERRUPT_RUNNING(heap)             DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
+#define DUK_HEAP_SET_FINALIZER_NORESCUE(heap)            DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
+#define DUK_HEAP_SET_DEBUGGER_PAUSED(heap)               DUK__HEAP_SET_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
 
-#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
-#define DUK_HEAP_CLEAR_INTERRUPT_RUNNING(heap)             DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
-#define DUK_HEAP_CLEAR_FINALIZER_NORESCUE(heap)            DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
-#define DUK_HEAP_CLEAR_DEBUGGER_PAUSED(heap)               DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
+#define DUK_HEAP_CLEAR_MARKANDSWEEP_RECLIMIT_REACHED(heap) \
+	DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_MARKANDSWEEP_RECLIMIT_REACHED)
+#define DUK_HEAP_CLEAR_INTERRUPT_RUNNING(heap)  DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_INTERRUPT_RUNNING)
+#define DUK_HEAP_CLEAR_FINALIZER_NORESCUE(heap) DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_FINALIZER_NORESCUE)
+#define DUK_HEAP_CLEAR_DEBUGGER_PAUSED(heap)    DUK__HEAP_CLEAR_FLAGS((heap), DUK_HEAP_FLAG_DEBUGGER_PAUSED)
 
 /*
  *  Longjmp types, also double as identifying continuation type for a rethrow (in 'finally')
  */
 
-#define DUK_LJ_TYPE_UNKNOWN      0    /* unused */
-#define DUK_LJ_TYPE_THROW        1    /* value1 -> error object */
-#define DUK_LJ_TYPE_YIELD        2    /* value1 -> yield value, iserror -> error / normal */
-#define DUK_LJ_TYPE_RESUME       3    /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */
-#define DUK_LJ_TYPE_BREAK        4    /* value1 -> label number, pseudo-type to indicate a break continuation (for ENDFIN) */
-#define DUK_LJ_TYPE_CONTINUE     5    /* value1 -> label number, pseudo-type to indicate a continue continuation (for ENDFIN) */
-#define DUK_LJ_TYPE_RETURN       6    /* value1 -> return value, pseudo-type to indicate a return continuation (for ENDFIN) */
-#define DUK_LJ_TYPE_NORMAL       7    /* no value, pseudo-type to indicate a normal continuation (for ENDFIN) */
+#define DUK_LJ_TYPE_UNKNOWN  0 /* unused */
+#define DUK_LJ_TYPE_THROW    1 /* value1 -> error object */
+#define DUK_LJ_TYPE_YIELD    2 /* value1 -> yield value, iserror -> error / normal */
+#define DUK_LJ_TYPE_RESUME   3 /* value1 -> resume value, value2 -> resumee thread, iserror -> error/normal */
+#define DUK_LJ_TYPE_BREAK    4 /* value1 -> label number, pseudo-type to indicate a break continuation (for ENDFIN) */
+#define DUK_LJ_TYPE_CONTINUE 5 /* value1 -> label number, pseudo-type to indicate a continue continuation (for ENDFIN) */
+#define DUK_LJ_TYPE_RETURN   6 /* value1 -> return value, pseudo-type to indicate a return continuation (for ENDFIN) */
+#define DUK_LJ_TYPE_NORMAL   7 /* no value, pseudo-type to indicate a normal continuation (for ENDFIN) */
 
 /*
  *  Mark-and-sweep flags
@@ -8549,19 +9043,19 @@
 /* Emergency mark-and-sweep: try extra hard, even at the cost of
  * performance.
  */
-#define DUK_MS_FLAG_EMERGENCY                (1U << 0)
+#define DUK_MS_FLAG_EMERGENCY (1U << 0)
 
 /* Postpone rescue decisions for reachable objects with FINALIZED set.
  * Used during finalize_list processing to avoid incorrect rescue
  * decisions due to finalize_list being a reachability root.
  */
-#define DUK_MS_FLAG_POSTPONE_RESCUE          (1U << 1)
+#define DUK_MS_FLAG_POSTPONE_RESCUE (1U << 1)
 
 /* Don't compact objects; needed during object property table resize
  * to prevent a recursive resize.  It would suffice to protect only the
  * current object being resized, but this is not yet implemented.
  */
-#define DUK_MS_FLAG_NO_OBJECT_COMPACTION     (1U << 2)
+#define DUK_MS_FLAG_NO_OBJECT_COMPACTION (1U << 2)
 
 /*
  *  Thread switching
@@ -8572,9 +9066,10 @@
  */
 
 #if defined(DUK_USE_INTERRUPT_COUNTER)
-#define DUK_HEAP_SWITCH_THREAD(heap,newthr)  duk_heap_switch_thread((heap), (newthr))
+#define DUK_HEAP_SWITCH_THREAD(heap, newthr) duk_heap_switch_thread((heap), (newthr))
 #else
-#define DUK_HEAP_SWITCH_THREAD(heap,newthr)  do { \
+#define DUK_HEAP_SWITCH_THREAD(heap, newthr) \
+	do { \
 		(heap)->curr_thread = (newthr); \
 	} while (0)
 #endif
@@ -8584,11 +9079,14 @@
  */
 
 #if defined(DUK_USE_DEBUG)
-#define DUK_STATS_INC(heap,fieldname) do { \
+#define DUK_STATS_INC(heap, fieldname) \
+	do { \
 		(heap)->fieldname += 1; \
 	} while (0)
 #else
-#define DUK_STATS_INC(heap,fieldname) do {} while (0)
+#define DUK_STATS_INC(heap, fieldname) \
+	do { \
+	} while (0)
 #endif
 
 /*
@@ -8606,36 +9104,41 @@
  * only during init phases).
  */
 #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
+#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
+#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
 
 /* GC torture. */
 #if defined(DUK_USE_GC_TORTURE)
-#define DUK_GC_TORTURE(heap) do { duk_heap_mark_and_sweep((heap), 0); } while (0)
+#define DUK_GC_TORTURE(heap) \
+	do { \
+		duk_heap_mark_and_sweep((heap), 0); \
+	} while (0)
 #else
-#define DUK_GC_TORTURE(heap) do { } while (0)
+#define DUK_GC_TORTURE(heap) \
+	do { \
+	} while (0)
 #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 */
+#define DUK_HEAP_STRCACHE_SIZE             4
+#define DUK_HEAP_STRINGCACHE_NOCACHE_LIMIT 16 /* strings up to the this length are not cached */
 
 /* Some list management macros. */
-#define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap,hdr)     duk_heap_insert_into_heap_allocated((heap), (hdr))
+#define DUK_HEAP_INSERT_INTO_HEAP_ALLOCATED(heap, hdr) duk_heap_insert_into_heap_allocated((heap), (hdr))
 #if defined(DUK_USE_REFERENCE_COUNTING)
-#define DUK_HEAP_REMOVE_FROM_HEAP_ALLOCATED(heap,hdr)     duk_heap_remove_from_heap_allocated((heap), (hdr))
+#define DUK_HEAP_REMOVE_FROM_HEAP_ALLOCATED(heap, hdr) duk_heap_remove_from_heap_allocated((heap), (hdr))
 #endif
 #if defined(DUK_USE_FINALIZER_SUPPORT)
-#define DUK_HEAP_INSERT_INTO_FINALIZE_LIST(heap,hdr)      duk_heap_insert_into_finalize_list((heap), (hdr))
-#define DUK_HEAP_REMOVE_FROM_FINALIZE_LIST(heap,hdr)      duk_heap_remove_from_finalize_list((heap), (hdr))
+#define DUK_HEAP_INSERT_INTO_FINALIZE_LIST(heap, hdr) duk_heap_insert_into_finalize_list((heap), (hdr))
+#define DUK_HEAP_REMOVE_FROM_FINALIZE_LIST(heap, hdr) duk_heap_remove_from_finalize_list((heap), (hdr))
 #endif
 
 /*
@@ -8644,30 +9147,24 @@
 
 /* heap string indices are autogenerated in duk_strings.h */
 #if defined(DUK_USE_ROM_STRINGS)
-#define DUK_HEAP_GET_STRING(heap,idx) \
-	((duk_hstring *) DUK_LOSE_CONST(duk_rom_strings_stridx[(idx)]))
-#else  /* DUK_USE_ROM_STRINGS */
+#define DUK_HEAP_GET_STRING(heap, idx) ((duk_hstring *) DUK_LOSE_CONST(duk_rom_strings_stridx[(idx)]))
+#else /* DUK_USE_ROM_STRINGS */
 #if defined(DUK_USE_HEAPPTR16)
-#define DUK_HEAP_GET_STRING(heap,idx) \
-	((duk_hstring *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (heap)->strs16[(idx)]))
+#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)])
+#define DUK_HEAP_GET_STRING(heap, idx) ((heap)->strs[(idx)])
 #endif
-#endif  /* DUK_USE_ROM_STRINGS */
+#endif /* DUK_USE_ROM_STRINGS */
 
 /*
  *  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_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_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)))
+#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.
@@ -8700,11 +9197,11 @@
 /* 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))
+#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))
 
 /*
  *  Checked allocation, relative to a thread
@@ -8713,24 +9210,26 @@
  *  for convenience.
  */
 
-#define DUK_ALLOC_CHECKED(thr,size)                     duk_heap_mem_alloc_checked((thr), (size))
-#define DUK_ALLOC_CHECKED_ZEROED(thr,size)              duk_heap_mem_alloc_checked_zeroed((thr), (size))
-#define DUK_FREE_CHECKED(thr,ptr)                       duk_heap_mem_free((thr)->heap, (ptr))
+#define DUK_ALLOC_CHECKED(thr, size)        duk_heap_mem_alloc_checked((thr), (size))
+#define DUK_ALLOC_CHECKED_ZEROED(thr, size) duk_heap_mem_alloc_checked_zeroed((thr), (size))
+#define DUK_FREE_CHECKED(thr, ptr)          duk_heap_mem_free((thr)->heap, (ptr))
 
 /*
  *  Memory constants
  */
 
-#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_LIMIT           10  /* 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_LIMIT \
+	10 /* 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.
-                                                              */
+#define DUK_HEAP_ALLOC_FAIL_MARKANDSWEEP_EMERGENCY_LIMIT \
+	3 /* Starting from this round, use emergency mode \
+	   * for mark-and-sweep. \
+	   */
 
 /*
  *  Debugger support
@@ -8739,26 +9238,26 @@
 /* Maximum number of breakpoints.  Only breakpoints that are set are
  * consulted so increasing this has no performance impact.
  */
-#define DUK_HEAP_MAX_BREAKPOINTS          16
+#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
+#define DUK_HEAP_DBG_RATELIMIT_OPCODES 4000
 
 /* Milliseconds between status notify and transport peeks. */
-#define DUK_HEAP_DBG_RATELIMIT_MILLISECS  200
+#define DUK_HEAP_DBG_RATELIMIT_MILLISECS 200
 
 /* Debugger pause flags. */
-#define DUK_PAUSE_FLAG_ONE_OPCODE        (1U << 0)   /* pause when a single opcode has been executed */
-#define DUK_PAUSE_FLAG_ONE_OPCODE_ACTIVE (1U << 1)   /* one opcode pause actually active; artifact of current implementation */
-#define DUK_PAUSE_FLAG_LINE_CHANGE       (1U << 2)   /* pause when current line number changes */
-#define DUK_PAUSE_FLAG_FUNC_ENTRY        (1U << 3)   /* pause when entering a function */
-#define DUK_PAUSE_FLAG_FUNC_EXIT         (1U << 4)   /* pause when exiting current function */
-#define DUK_PAUSE_FLAG_CAUGHT_ERROR      (1U << 5)   /* pause when about to throw an error that is caught */
-#define DUK_PAUSE_FLAG_UNCAUGHT_ERROR    (1U << 6)   /* pause when about to throw an error that won't be caught */
+#define DUK_PAUSE_FLAG_ONE_OPCODE        (1U << 0) /* pause when a single opcode has been executed */
+#define DUK_PAUSE_FLAG_ONE_OPCODE_ACTIVE (1U << 1) /* one opcode pause actually active; artifact of current implementation */
+#define DUK_PAUSE_FLAG_LINE_CHANGE       (1U << 2) /* pause when current line number changes */
+#define DUK_PAUSE_FLAG_FUNC_ENTRY        (1U << 3) /* pause when entering a function */
+#define DUK_PAUSE_FLAG_FUNC_EXIT         (1U << 4) /* pause when exiting current function */
+#define DUK_PAUSE_FLAG_CAUGHT_ERROR      (1U << 5) /* pause when about to throw an error that is caught */
+#define DUK_PAUSE_FLAG_UNCAUGHT_ERROR    (1U << 6) /* pause when about to throw an error that won't be caught */
 
 struct duk_breakpoint {
 	duk_hstring *filename;
@@ -8786,21 +9285,23 @@
  */
 
 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) */
+	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) */
 };
 
-#define DUK_ASSERT_LJSTATE_UNSET(heap) do { \
+#define DUK_ASSERT_LJSTATE_UNSET(heap) \
+	do { \
 		DUK_ASSERT(heap != NULL); \
 		DUK_ASSERT(heap->lj.type == DUK_LJ_TYPE_UNKNOWN); \
 		DUK_ASSERT(heap->lj.iserror == 0); \
 		DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&heap->lj.value1)); \
 		DUK_ASSERT(DUK_TVAL_IS_UNDEFINED(&heap->lj.value2)); \
 	} while (0)
-#define DUK_ASSERT_LJSTATE_SET(heap) do { \
+#define DUK_ASSERT_LJSTATE_SET(heap) \
+	do { \
 		DUK_ASSERT(heap != NULL); \
 		DUK_ASSERT(heap->lj.type != DUK_LJ_TYPE_UNKNOWN); \
 	} while (0)
@@ -8820,9 +9321,14 @@
 
 #if defined(DUK_USE_ASSERTIONS)
 DUK_INTERNAL_DECL void duk_heap_assert_valid(duk_heap *heap);
-#define DUK_HEAP_ASSERT_VALID(heap)  do { duk_heap_assert_valid((heap)); } while (0)
+#define DUK_HEAP_ASSERT_VALID(heap) \
+	do { \
+		duk_heap_assert_valid((heap)); \
+	} while (0)
 #else
-#define DUK_HEAP_ASSERT_VALID(heap)  do {} while (0)
+#define DUK_HEAP_ASSERT_VALID(heap) \
+	do { \
+	} while (0)
 #endif
 
 struct duk_heap {
@@ -8976,9 +9482,9 @@
 	/* Random number state for duk_util_tinyrandom.c. */
 #if !defined(DUK_USE_GET_RANDOM_DOUBLE)
 #if defined(DUK_USE_PREFER_SIZE) || !defined(DUK_USE_64BIT_OPS)
-	duk_uint32_t rnd_state;  /* State for Shamir's three-op algorithm */
+	duk_uint32_t rnd_state; /* State for Shamir's three-op algorithm */
 #else
-	duk_uint64_t rnd_state[2];  /* State for xoroshiro128+ */
+	duk_uint64_t rnd_state[2]; /* State for xoroshiro128+ */
 #endif
 #endif
 
@@ -9001,8 +9507,8 @@
 	/* Debugger state. */
 #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_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;
@@ -9011,29 +9517,32 @@
 	void *dbg_udata;
 
 	/* The following are only relevant when debugger is 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_state_dirty;             /* resend state next time executor is about to run */
-	duk_bool_t dbg_force_restart;           /* force executor restart to recheck breakpoints; used to handle function returns (see GH-303) */
-	duk_bool_t dbg_detaching;               /* debugger detaching; used to avoid calling detach handler recursively */
-	duk_small_uint_t dbg_pause_flags;       /* flags for automatic pause behavior */
-	duk_activation *dbg_pause_act;          /* activation related to pause behavior (pause on line change, function entry/exit) */
-	duk_uint32_t dbg_pause_startline;       /* starting line number for line change related pause behavior */
-	duk_breakpoint dbg_breakpoints[DUK_HEAP_MAX_BREAKPOINTS];  /* breakpoints: [0,breakpoint_count[ gc reachable */
+	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_state_dirty; /* resend state next time executor is about to run */
+	duk_bool_t
+	    dbg_force_restart; /* force executor restart to recheck breakpoints; used to handle function returns (see GH-303) */
+	duk_bool_t dbg_detaching; /* debugger detaching; used to avoid calling detach handler recursively */
+	duk_small_uint_t dbg_pause_flags; /* flags for automatic pause behavior */
+	duk_activation *dbg_pause_act; /* activation related to pause behavior (pause on line change, function entry/exit) */
+	duk_uint32_t dbg_pause_startline; /* starting line number for line change related pause behavior */
+	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 */
+	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_uint_t dbg_exec_counter;            /* cumulative opcode execution count (overflows are OK) */
-	duk_uint_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) */
+	duk_uint_t dbg_exec_counter; /* cumulative opcode execution count (overflows are OK) */
+	duk_uint_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) */
 
 	/* Used to support single-byte stream lookahead. */
 	duk_bool_t dbg_have_next_byte;
 	duk_uint8_t dbg_next_byte;
-#endif  /* DUK_USE_DEBUGGER_SUPPORT */
+#endif /* DUK_USE_DEBUGGER_SUPPORT */
 #if defined(DUK_USE_ASSERTIONS)
-	duk_bool_t dbg_calling_transport;       /* transport call in progress, calling into Duktape forbidden */
+	duk_bool_t dbg_calling_transport; /* transport call in progress, calling into Duktape forbidden */
 #endif
 
 	/* String intern table (weak refs). */
@@ -9042,12 +9551,12 @@
 #else
 	duk_hstring **strtable;
 #endif
-	duk_uint32_t st_mask;    /* mask for lookup, st_size - 1 */
-	duk_uint32_t st_size;    /* stringtable size */
+	duk_uint32_t st_mask; /* mask for lookup, st_size - 1 */
+	duk_uint32_t st_size; /* stringtable size */
 #if (DUK_USE_STRTAB_MINSIZE != DUK_USE_STRTAB_MAXSIZE)
-	duk_uint32_t st_count;   /* string count for resize load factor checks */
+	duk_uint32_t st_count; /* string count for resize load factor checks */
 #endif
-	duk_bool_t st_resizing;  /* string table is being resized; avoid recursive resize */
+	duk_bool_t st_resizing; /* string table is being resized; avoid recursive resize */
 
 	/* String access cache (codepoint offset -> byte offset) for fast string
 	 * character looping; 'weak' reference which needs special handling in GC.
@@ -9161,7 +9670,9 @@
 DUK_INTERNAL_DECL duk_hstring *duk_heap_strtable_intern(duk_heap *heap, const duk_uint8_t *str, duk_uint32_t blen);
 DUK_INTERNAL_DECL duk_hstring *duk_heap_strtable_intern_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t len);
 #if defined(DUK_USE_LITCACHE_SIZE)
-DUK_INTERNAL_DECL duk_hstring *duk_heap_strtable_intern_literal_checked(duk_hthread *thr, const duk_uint8_t *str, duk_uint32_t blen);
+DUK_INTERNAL_DECL duk_hstring *duk_heap_strtable_intern_literal_checked(duk_hthread *thr,
+                                                                        const duk_uint8_t *str,
+                                                                        duk_uint32_t blen);
 #endif
 DUK_INTERNAL_DECL duk_hstring *duk_heap_strtable_intern_u32(duk_heap *heap, duk_uint32_t val);
 DUK_INTERNAL_DECL duk_hstring *duk_heap_strtable_intern_u32_checked(duk_hthread *thr, duk_uint32_t val);
@@ -9176,7 +9687,9 @@
 #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);
+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);
@@ -9197,13 +9710,13 @@
 #if defined(DUK_USE_FINALIZER_SUPPORT)
 DUK_INTERNAL_DECL void duk_heap_run_finalizer(duk_heap *heap, duk_hobject *obj);
 DUK_INTERNAL_DECL void duk_heap_process_finalize_list(duk_heap *heap);
-#endif  /* DUK_USE_FINALIZER_SUPPORT */
+#endif /* DUK_USE_FINALIZER_SUPPORT */
 
 DUK_INTERNAL_DECL void duk_heap_mark_and_sweep(duk_heap *heap, duk_small_uint_t flags);
 
 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 */
+#endif /* DUK_HEAP_H_INCLUDED */
 /* #include duk_debugger.h */
 #line 1 "duk_debugger.h"
 #if !defined(DUK_DEBUGGER_H_INCLUDED)
@@ -9212,77 +9725,77 @@
 /* Debugger protocol version is defined in the public API header. */
 
 /* Initial bytes for markers. */
-#define DUK_DBG_IB_EOM                   0x00
-#define DUK_DBG_IB_REQUEST               0x01
-#define DUK_DBG_IB_REPLY                 0x02
-#define DUK_DBG_IB_ERROR                 0x03
-#define DUK_DBG_IB_NOTIFY                0x04
+#define DUK_DBG_IB_EOM     0x00
+#define DUK_DBG_IB_REQUEST 0x01
+#define DUK_DBG_IB_REPLY   0x02
+#define DUK_DBG_IB_ERROR   0x03
+#define DUK_DBG_IB_NOTIFY  0x04
 
 /* Other initial bytes. */
-#define DUK_DBG_IB_INT4                  0x10
-#define DUK_DBG_IB_STR4                  0x11
-#define DUK_DBG_IB_STR2                  0x12
-#define DUK_DBG_IB_BUF4                  0x13
-#define DUK_DBG_IB_BUF2                  0x14
-#define DUK_DBG_IB_UNUSED                0x15
-#define DUK_DBG_IB_UNDEFINED             0x16
-#define DUK_DBG_IB_NULL                  0x17
-#define DUK_DBG_IB_TRUE                  0x18
-#define DUK_DBG_IB_FALSE                 0x19
-#define DUK_DBG_IB_NUMBER                0x1a
-#define DUK_DBG_IB_OBJECT                0x1b
-#define DUK_DBG_IB_POINTER               0x1c
-#define DUK_DBG_IB_LIGHTFUNC             0x1d
-#define DUK_DBG_IB_HEAPPTR               0x1e
+#define DUK_DBG_IB_INT4      0x10
+#define DUK_DBG_IB_STR4      0x11
+#define DUK_DBG_IB_STR2      0x12
+#define DUK_DBG_IB_BUF4      0x13
+#define DUK_DBG_IB_BUF2      0x14
+#define DUK_DBG_IB_UNUSED    0x15
+#define DUK_DBG_IB_UNDEFINED 0x16
+#define DUK_DBG_IB_NULL      0x17
+#define DUK_DBG_IB_TRUE      0x18
+#define DUK_DBG_IB_FALSE     0x19
+#define DUK_DBG_IB_NUMBER    0x1a
+#define DUK_DBG_IB_OBJECT    0x1b
+#define DUK_DBG_IB_POINTER   0x1c
+#define DUK_DBG_IB_LIGHTFUNC 0x1d
+#define DUK_DBG_IB_HEAPPTR   0x1e
 /* The short string/integer initial bytes starting from 0x60 don't have
  * defines now.
  */
 
 /* Error codes. */
-#define DUK_DBG_ERR_UNKNOWN              0x00
-#define DUK_DBG_ERR_UNSUPPORTED          0x01
-#define DUK_DBG_ERR_TOOMANY              0x02
-#define DUK_DBG_ERR_NOTFOUND             0x03
-#define DUK_DBG_ERR_APPLICATION          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
+#define DUK_DBG_ERR_APPLICATION 0x04
 
 /* Commands and notifys initiated by Duktape. */
-#define DUK_DBG_CMD_STATUS               0x01
-#define DUK_DBG_CMD_UNUSED_2             0x02  /* Duktape 1.x: print notify */
-#define DUK_DBG_CMD_UNUSED_3             0x03  /* Duktape 1.x: alert notify */
-#define DUK_DBG_CMD_UNUSED_4             0x04  /* Duktape 1.x: log notify */
-#define DUK_DBG_CMD_THROW                0x05
-#define DUK_DBG_CMD_DETACHING            0x06
-#define DUK_DBG_CMD_APPNOTIFY            0x07
+#define DUK_DBG_CMD_STATUS    0x01
+#define DUK_DBG_CMD_UNUSED_2  0x02 /* Duktape 1.x: print notify */
+#define DUK_DBG_CMD_UNUSED_3  0x03 /* Duktape 1.x: alert notify */
+#define DUK_DBG_CMD_UNUSED_4  0x04 /* Duktape 1.x: log notify */
+#define DUK_DBG_CMD_THROW     0x05
+#define DUK_DBG_CMD_DETACHING 0x06
+#define DUK_DBG_CMD_APPNOTIFY 0x07
 
 /* Commands 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
-#define DUK_DBG_CMD_APPREQUEST           0x22
-#define DUK_DBG_CMD_GETHEAPOBJINFO       0x23
-#define DUK_DBG_CMD_GETOBJPROPDESC       0x24
-#define DUK_DBG_CMD_GETOBJPROPDESCRANGE  0x25
+#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
+#define DUK_DBG_CMD_APPREQUEST          0x22
+#define DUK_DBG_CMD_GETHEAPOBJINFO      0x23
+#define DUK_DBG_CMD_GETOBJPROPDESC      0x24
+#define DUK_DBG_CMD_GETOBJPROPDESCRANGE 0x25
 
 /* The low 8 bits map directly to duk_hobject.h DUK_PROPDESC_FLAG_xxx.
  * The remaining flags are specific to the debugger.
  */
-#define DUK_DBG_PROPFLAG_SYMBOL          (1U << 8)
-#define DUK_DBG_PROPFLAG_HIDDEN          (1U << 9)
+#define DUK_DBG_PROPFLAG_SYMBOL (1U << 8)
+#define DUK_DBG_PROPFLAG_HIDDEN (1U << 9)
 
 #if defined(DUK_USE_DEBUGGER_SUPPORT)
 DUK_INTERNAL_DECL void duk_debug_do_detach(duk_heap *heap);
@@ -9329,7 +9842,7 @@
 #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 */
+#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);
@@ -9354,9 +9867,9 @@
 DUK_INTERNAL_DECL void duk_debug_set_paused(duk_heap *heap);
 DUK_INTERNAL_DECL void duk_debug_clear_paused(duk_heap *heap);
 DUK_INTERNAL_DECL void duk_debug_clear_pause_state(duk_heap *heap);
-#endif  /* DUK_USE_DEBUGGER_SUPPORT */
+#endif /* DUK_USE_DEBUGGER_SUPPORT */
 
-#endif  /* DUK_DEBUGGER_H_INCLUDED */
+#endif /* DUK_DEBUGGER_H_INCLUDED */
 /* #include duk_debug.h */
 #line 1 "duk_debug.h"
 /*
@@ -9389,19 +9902,25 @@
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 0)
 #define DUK_D(x) x
 #else
-#define DUK_D(x) do { } while (0) /* omit */
+#define DUK_D(x) \
+	do { \
+	} while (0) /* omit */
 #endif
 
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 1)
 #define DUK_DD(x) x
 #else
-#define DUK_DD(x) do { } while (0) /* omit */
+#define DUK_DD(x) \
+	do { \
+	} while (0) /* omit */
 #endif
 
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 2)
 #define DUK_DDD(x) x
 #else
-#define DUK_DDD(x) do { } while (0) /* omit */
+#define DUK_DDD(x) \
+	do { \
+	} while (0) /* omit */
 #endif
 
 /*
@@ -9413,35 +9932,35 @@
 /* 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_int_t) (lev), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, DUK_FUNC_MACRO, __VA_ARGS__);
+#define DUK__DEBUG_LOG(lev, ...) \
+	duk_debug_log((duk_int_t) (lev), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, DUK_FUNC_MACRO, __VA_ARGS__);
 
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 0)
-#define DUK_DPRINT(...)          DUK__DEBUG_LOG(DUK_LEVEL_DEBUG, __VA_ARGS__)
+#define DUK_DPRINT(...) DUK__DEBUG_LOG(DUK_LEVEL_DEBUG, __VA_ARGS__)
 #else
 #define DUK_DPRINT(...)
 #endif
 
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 1)
-#define DUK_DDPRINT(...)         DUK__DEBUG_LOG(DUK_LEVEL_DDEBUG, __VA_ARGS__)
+#define DUK_DDPRINT(...) DUK__DEBUG_LOG(DUK_LEVEL_DDEBUG, __VA_ARGS__)
 #else
 #define DUK_DDPRINT(...)
 #endif
 
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 2)
-#define DUK_DDDPRINT(...)        DUK__DEBUG_LOG(DUK_LEVEL_DDDEBUG, __VA_ARGS__)
+#define DUK_DDDPRINT(...) DUK__DEBUG_LOG(DUK_LEVEL_DDDEBUG, __VA_ARGS__)
 #else
 #define DUK_DDDPRINT(...)
 #endif
 
-#else  /* DUK_USE_VARIADIC_MACROS */
+#else /* DUK_USE_VARIADIC_MACROS */
 
-#define DUK__DEBUG_STASH(lev)    \
+#define DUK__DEBUG_STASH(lev) \
 	(void) DUK_SNPRINTF(duk_debug_file_stash, DUK_DEBUG_STASH_SIZE, "%s", (const char *) DUK_FILE_MACRO), \
-	(void) (duk_debug_file_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0), \
-	(void) (duk_debug_line_stash = (duk_int_t) DUK_LINE_MACRO), \
-	(void) DUK_SNPRINTF(duk_debug_func_stash, DUK_DEBUG_STASH_SIZE, "%s", (const char *) DUK_FUNC_MACRO), \
-	(void) (duk_debug_func_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0), \
-	(void) (duk_debug_level_stash = (lev))
+	    (void) (duk_debug_file_stash[DUK_DEBUG_STASH_SIZE - 1] = (char) 0), \
+	    (void) (duk_debug_line_stash = (duk_int_t) DUK_LINE_MACRO), \
+	    (void) DUK_SNPRINTF(duk_debug_func_stash, DUK_DEBUG_STASH_SIZE, "%s", (const char *) DUK_FUNC_MACRO), \
+	    (void) (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
@@ -9450,34 +9969,40 @@
  */
 
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 0)
-#define DUK_DPRINT  DUK__DEBUG_STASH(DUK_LEVEL_DEBUG), (void) duk_debug_log  /* args go here in parens */
+#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 */
+#define DUK_DPRINT 0 && /* args go here as a comma expression in parens */
 #endif
 
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 1)
-#define DUK_DDPRINT  DUK__DEBUG_STASH(DUK_LEVEL_DDEBUG), (void) duk_debug_log  /* args go here in parens */
+#define DUK_DDPRINT DUK__DEBUG_STASH(DUK_LEVEL_DDEBUG), (void) duk_debug_log /* args go here in parens */
 #else
-#define DUK_DDPRINT  0 && /* args */
+#define DUK_DDPRINT 0 && /* args */
 #endif
 
 #if defined(DUK_USE_DEBUG_LEVEL) && (DUK_USE_DEBUG_LEVEL >= 2)
-#define DUK_DDDPRINT  DUK__DEBUG_STASH(DUK_LEVEL_DDDEBUG), (void) duk_debug_log  /* args go here in parens */
+#define DUK_DDDPRINT DUK__DEBUG_STASH(DUK_LEVEL_DDDEBUG), (void) duk_debug_log /* args go here in parens */
 #else
-#define DUK_DDDPRINT  0 && /* args */
+#define DUK_DDDPRINT 0 && /* args */
 #endif
 
-#endif  /* DUK_USE_VARIADIC_MACROS */
+#endif /* DUK_USE_VARIADIC_MACROS */
 
-#else  /* DUK_USE_DEBUG */
+#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 */
+#define DUK_D(x) \
+	do { \
+	} while (0) /* omit */
+#define DUK_DD(x) \
+	do { \
+	} while (0) /* omit */
+#define DUK_DDD(x) \
+	do { \
+	} while (0) /* omit */
 
 #if defined(DUK_USE_VARIADIC_MACROS)
 
@@ -9485,15 +10010,15 @@
 #define DUK_DDPRINT(...)
 #define DUK_DDDPRINT(...)
 
-#else  /* DUK_USE_VARIADIC_MACROS */
+#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 */
+#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_VARIADIC_MACROS */
 
-#endif  /* DUK_USE_DEBUG */
+#endif /* DUK_USE_DEBUG */
 
 /*
  *  Structs
@@ -9514,16 +10039,16 @@
 
 #if defined(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*/
+#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);
 
 #if defined(DUK_USE_VARIADIC_MACROS)
 DUK_INTERNAL_DECL void duk_debug_log(duk_int_t level, const char *file, duk_int_t line, const char *func, const char *fmt, ...);
-#else  /* DUK_USE_VARIADIC_MACROS */
+#else /* DUK_USE_VARIADIC_MACROS */
 /* parameter passing, not thread safe */
-#define DUK_DEBUG_STASH_SIZE  128
+#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 duk_int_t duk_debug_line_stash;
@@ -9531,7 +10056,7 @@
 DUK_INTERNAL_DECL duk_int_t duk_debug_level_stash;
 #endif
 DUK_INTERNAL_DECL void duk_debug_log(const char *fmt, ...);
-#endif  /* DUK_USE_VARIADIC_MACROS */
+#endif /* DUK_USE_VARIADIC_MACROS */
 
 DUK_INTERNAL_DECL void duk_fb_put_bytes(duk_fixedbuffer *fb, const duk_uint8_t *buffer, duk_size_t length);
 DUK_INTERNAL_DECL void duk_fb_put_byte(duk_fixedbuffer *fb, duk_uint8_t x);
@@ -9540,9 +10065,9 @@
 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_USE_DEBUG */
 
-#endif  /* DUK_DEBUG_H_INCLUDED */
+#endif /* DUK_DEBUG_H_INCLUDED */
 /* #include duk_error.h */
 #line 1 "duk_error.h"
 /*
@@ -9600,79 +10125,153 @@
 /* Because there are quite many call sites, pack error code (require at most
  * 8-bit) into a single argument.
  */
-#define DUK_ERROR(thr,err,msg) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+#define DUK_ERROR(thr, err, msg) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
 		duk_err_handle_error((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
 	} while (0)
-#define DUK_ERROR_RAW(thr,file,line,err,msg) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+#define DUK_ERROR_RAW(thr, file, line, err, msg) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) (line); \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
 		duk_err_handle_error((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (msg)); \
 	} while (0)
 
-#define DUK_ERROR_FMT1(thr,err,fmt,arg1) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
+#define DUK_ERROR_FMT1(thr, err, fmt, arg1) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+		duk_err_handle_error_fmt((thr), \
+		                         DUK_FILE_MACRO, \
+		                         (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), \
+		                         (fmt), \
+		                         (arg1)); \
 	} while (0)
-#define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1)); \
+#define DUK_ERROR_RAW_FMT1(thr, file, line, err, fmt, arg1) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) (line); \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+		duk_err_handle_error_fmt((thr), \
+		                         (file), \
+		                         (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), \
+		                         (fmt), \
+		                         (arg1)); \
 	} while (0)
 
-#define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
+#define DUK_ERROR_FMT2(thr, err, fmt, arg1, arg2) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+		duk_err_handle_error_fmt((thr), \
+		                         DUK_FILE_MACRO, \
+		                         (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), \
+		                         (fmt), \
+		                         (arg1), \
+		                         (arg2)); \
 	} while (0)
-#define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2)); \
+#define DUK_ERROR_RAW_FMT2(thr, file, line, err, fmt, arg1, arg2) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) (line); \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+		duk_err_handle_error_fmt((thr), \
+		                         (file), \
+		                         (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), \
+		                         (fmt), \
+		                         (arg1), \
+		                         (arg2)); \
 	} while (0)
 
-#define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
+#define DUK_ERROR_FMT3(thr, err, fmt, arg1, arg2, arg3) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+		duk_err_handle_error_fmt((thr), \
+		                         DUK_FILE_MACRO, \
+		                         (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), \
+		                         (fmt), \
+		                         (arg1), \
+		                         (arg2), \
+		                         (arg3)); \
 	} while (0)
-#define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3)); \
+#define DUK_ERROR_RAW_FMT3(thr, file, line, err, fmt, arg1, arg2, arg3) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) (line); \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+		duk_err_handle_error_fmt((thr), \
+		                         (file), \
+		                         (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), \
+		                         (fmt), \
+		                         (arg1), \
+		                         (arg2), \
+		                         (arg3)); \
 	} while (0)
 
-#define DUK_ERROR_FMT4(thr,err,fmt,arg1,arg2,arg3,arg4) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), DUK_FILE_MACRO, (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \
+#define DUK_ERROR_FMT4(thr, err, fmt, arg1, arg2, arg3, arg4) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) DUK_LINE_MACRO; \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+		duk_err_handle_error_fmt((thr), \
+		                         DUK_FILE_MACRO, \
+		                         (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), \
+		                         (fmt), \
+		                         (arg1), \
+		                         (arg2), \
+		                         (arg3), \
+		                         (arg4)); \
 	} while (0)
-#define DUK_ERROR_RAW_FMT4(thr,file,line,err,fmt,arg1,arg2,arg3,arg4) do { \
-		duk_errcode_t duk__err = (err); duk_int_t duk__line = (duk_int_t) (line); \
-		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
-		duk_err_handle_error_fmt((thr), (file), (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), (fmt), (arg1), (arg2), (arg3), (arg4)); \
+#define DUK_ERROR_RAW_FMT4(thr, file, line, err, fmt, arg1, arg2, arg3, arg4) \
+	do { \
+		duk_errcode_t duk__err = (err); \
+		duk_int_t duk__line = (duk_int_t) (line); \
+		DUK_ASSERT(duk__err >= 0 && duk__err <= 0xff); \
+		DUK_ASSERT(duk__line >= 0 && duk__line <= 0x00ffffffL); \
+		duk_err_handle_error_fmt((thr), \
+		                         (file), \
+		                         (((duk_uint_t) duk__err) << 24) | ((duk_uint_t) duk__line), \
+		                         (fmt), \
+		                         (arg1), \
+		                         (arg2), \
+		                         (arg3), \
+		                         (arg4)); \
 	} while (0)
 
-#else  /* DUK_USE_VERBOSE_ERRORS */
+#else /* DUK_USE_VERBOSE_ERRORS */
 
-#define DUK_ERROR(thr,err,msg)                    duk_err_handle_error((thr), (err))
-#define DUK_ERROR_RAW(thr,file,line,err,msg)      duk_err_handle_error((thr), (err))
+#define DUK_ERROR(thr, err, msg)                 duk_err_handle_error((thr), (err))
+#define DUK_ERROR_RAW(thr, file, line, err, msg) duk_err_handle_error((thr), (err))
 
-#define DUK_ERROR_FMT1(thr,err,fmt,arg1) DUK_ERROR((thr),(err),(fmt))
-#define DUK_ERROR_RAW_FMT1(thr,file,line,err,fmt,arg1) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
+#define DUK_ERROR_FMT1(thr, err, fmt, arg1)                 DUK_ERROR((thr), (err), (fmt))
+#define DUK_ERROR_RAW_FMT1(thr, file, line, err, fmt, arg1) DUK_ERROR_RAW((thr), (file), (line), (err), (fmt))
 
-#define DUK_ERROR_FMT2(thr,err,fmt,arg1,arg2) DUK_ERROR((thr),(err),(fmt))
-#define DUK_ERROR_RAW_FMT2(thr,file,line,err,fmt,arg1,arg2) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
+#define DUK_ERROR_FMT2(thr, err, fmt, arg1, arg2)                 DUK_ERROR((thr), (err), (fmt))
+#define DUK_ERROR_RAW_FMT2(thr, file, line, err, fmt, arg1, arg2) DUK_ERROR_RAW((thr), (file), (line), (err), (fmt))
 
-#define DUK_ERROR_FMT3(thr,err,fmt,arg1,arg2,arg3) DUK_ERROR((thr),(err),(fmt))
-#define DUK_ERROR_RAW_FMT3(thr,file,line,err,fmt,arg1,arg2,arg3) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
+#define DUK_ERROR_FMT3(thr, err, fmt, arg1, arg2, arg3)                 DUK_ERROR((thr), (err), (fmt))
+#define DUK_ERROR_RAW_FMT3(thr, file, line, err, fmt, arg1, arg2, arg3) DUK_ERROR_RAW((thr), (file), (line), (err), (fmt))
 
-#define DUK_ERROR_FMT4(thr,err,fmt,arg1,arg2,arg3,arg4) DUK_ERROR((thr),(err),(fmt))
-#define DUK_ERROR_RAW_FMT4(thr,file,line,err,fmt,arg1,arg2,arg3,arg4) DUK_ERROR_RAW((thr),(file),(line),(err),(fmt))
+#define DUK_ERROR_FMT4(thr, err, fmt, arg1, arg2, arg3, arg4)                 DUK_ERROR((thr), (err), (fmt))
+#define DUK_ERROR_RAW_FMT4(thr, file, line, err, fmt, arg1, arg2, arg3, arg4) DUK_ERROR_RAW((thr), (file), (line), (err), (fmt))
 
-#endif  /* DUK_USE_VERBOSE_ERRORS */
+#endif /* DUK_USE_VERBOSE_ERRORS */
 
 /*
  *  Fatal error without context
@@ -9680,8 +10279,7 @@
  *  The macro is an expression to make it compatible with DUK_ASSERT_EXPR().
  */
 
-#define DUK_FATAL_WITHOUT_CONTEXT(msg) \
-	duk_default_fatal_handler(NULL, (msg))
+#define DUK_FATAL_WITHOUT_CONTEXT(msg) duk_default_fatal_handler(NULL, (msg))
 
 /*
  *  Error throwing helpers
@@ -9706,196 +10304,252 @@
  * vs. non-paranoid distinction affects only a few specific errors.
  */
 #if defined(DUK_USE_PARANOID_ERRORS)
-#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,idx,expectname,lowmemstr) do { \
+#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr, idx, expectname, lowmemstr) \
+	do { \
 		duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (idx), (expectname)); \
 	} while (0)
-#else  /* DUK_USE_PARANOID_ERRORS */
-#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,idx,expectname,lowmemstr) do { \
+#else /* DUK_USE_PARANOID_ERRORS */
+#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr, idx, expectname, lowmemstr) \
+	do { \
 		duk_err_require_type_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (idx), (expectname)); \
 	} while (0)
-#endif  /* DUK_USE_PARANOID_ERRORS */
+#endif /* DUK_USE_PARANOID_ERRORS */
 
-#define DUK_ERROR_INTERNAL(thr) do { \
+#define DUK_ERROR_INTERNAL(thr) \
+	do { \
 		duk_err_error_internal((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
 	} while (0)
-#define DUK_DCERROR_INTERNAL(thr) do { \
+#define DUK_DCERROR_INTERNAL(thr) \
+	do { \
 		DUK_ERROR_INTERNAL((thr)); \
 		return 0; \
 	} while (0)
-#define DUK_ERROR_ALLOC_FAILED(thr) do { \
+#define DUK_ERROR_ALLOC_FAILED(thr) \
+	do { \
 		duk_err_error_alloc_failed((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
 	} while (0)
-#define DUK_ERROR_UNSUPPORTED(thr) do { \
+#define DUK_ERROR_UNSUPPORTED(thr) \
+	do { \
 		DUK_ERROR((thr), DUK_ERR_ERROR, DUK_STR_UNSUPPORTED); \
 	} while (0)
-#define DUK_DCERROR_UNSUPPORTED(thr) do { \
+#define DUK_DCERROR_UNSUPPORTED(thr) \
+	do { \
 		DUK_ERROR_UNSUPPORTED((thr)); \
 		return 0; \
 	} while (0)
-#define DUK_ERROR_ERROR(thr,msg) do { \
+#define DUK_ERROR_ERROR(thr, msg) \
+	do { \
 		duk_err_error((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
 	} while (0)
-#define DUK_ERROR_RANGE_INDEX(thr,idx) do { \
+#define DUK_ERROR_RANGE_INDEX(thr, idx) \
+	do { \
 		duk_err_range_index((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (idx)); \
 	} while (0)
-#define DUK_ERROR_RANGE_PUSH_BEYOND(thr) do { \
+#define DUK_ERROR_RANGE_PUSH_BEYOND(thr) \
+	do { \
 		duk_err_range_push_beyond((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
 	} while (0)
-#define DUK_ERROR_RANGE_INVALID_ARGS(thr) do { \
+#define DUK_ERROR_RANGE_INVALID_ARGS(thr) \
+	do { \
 		DUK_ERROR_RANGE((thr), DUK_STR_INVALID_ARGS); \
 	} while (0)
-#define DUK_DCERROR_RANGE_INVALID_ARGS(thr) do { \
+#define DUK_DCERROR_RANGE_INVALID_ARGS(thr) \
+	do { \
 		DUK_ERROR_RANGE_INVALID_ARGS((thr)); \
 		return 0; \
 	} while (0)
-#define DUK_ERROR_RANGE_INVALID_COUNT(thr) do { \
+#define DUK_ERROR_RANGE_INVALID_COUNT(thr) \
+	do { \
 		DUK_ERROR_RANGE((thr), DUK_STR_INVALID_COUNT); \
 	} while (0)
-#define DUK_DCERROR_RANGE_INVALID_COUNT(thr) do { \
+#define DUK_DCERROR_RANGE_INVALID_COUNT(thr) \
+	do { \
 		DUK_ERROR_RANGE_INVALID_COUNT((thr)); \
 		return 0; \
 	} while (0)
-#define DUK_ERROR_RANGE_INVALID_LENGTH(thr) do { \
+#define DUK_ERROR_RANGE_INVALID_LENGTH(thr) \
+	do { \
 		DUK_ERROR_RANGE((thr), DUK_STR_INVALID_LENGTH); \
 	} while (0)
-#define DUK_DCERROR_RANGE_INVALID_LENGTH(thr) do { \
+#define DUK_DCERROR_RANGE_INVALID_LENGTH(thr) \
+	do { \
 		DUK_ERROR_RANGE_INVALID_LENGTH((thr)); \
 		return 0; \
 	} while (0)
-#define DUK_ERROR_RANGE(thr,msg) do { \
+#define DUK_ERROR_RANGE(thr, msg) \
+	do { \
 		duk_err_range((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO, (msg)); \
 	} while (0)
-#define DUK_ERROR_EVAL(thr,msg) do { \
+#define DUK_ERROR_EVAL(thr, msg) \
+	do { \
 		DUK_ERROR((thr), DUK_ERR_EVAL_ERROR, (msg)); \
 	} while (0)
-#define DUK_ERROR_REFERENCE(thr,msg) do { \
+#define DUK_ERROR_REFERENCE(thr, msg) \
+	do { \
 		DUK_ERROR((thr), DUK_ERR_REFERENCE_ERROR, (msg)); \
 	} while (0)
-#define DUK_ERROR_SYNTAX(thr,msg) do { \
+#define DUK_ERROR_SYNTAX(thr, msg) \
+	do { \
 		DUK_ERROR((thr), DUK_ERR_SYNTAX_ERROR, (msg)); \
 	} while (0)
-#define DUK_ERROR_TYPE_INVALID_ARGS(thr) do { \
+#define DUK_ERROR_TYPE_INVALID_ARGS(thr) \
+	do { \
 		duk_err_type_invalid_args((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
 	} while (0)
-#define DUK_DCERROR_TYPE_INVALID_ARGS(thr) do { \
+#define DUK_DCERROR_TYPE_INVALID_ARGS(thr) \
+	do { \
 		DUK_ERROR_TYPE_INVALID_ARGS((thr)); \
 		return 0; \
 	} while (0)
-#define DUK_ERROR_TYPE_INVALID_STATE(thr) do { \
+#define DUK_ERROR_TYPE_INVALID_STATE(thr) \
+	do { \
 		duk_err_type_invalid_state((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
 	} while (0)
-#define DUK_DCERROR_TYPE_INVALID_STATE(thr) do { \
+#define DUK_DCERROR_TYPE_INVALID_STATE(thr) \
+	do { \
 		DUK_ERROR_TYPE_INVALID_STATE((thr)); \
 		return 0; \
 	} while (0)
-#define DUK_ERROR_TYPE_INVALID_TRAP_RESULT(thr) do { \
+#define DUK_ERROR_TYPE_INVALID_TRAP_RESULT(thr) \
+	do { \
 		duk_err_type_invalid_trap_result((thr), DUK_FILE_MACRO, (duk_int_t) DUK_LINE_MACRO); \
 	} while (0)
-#define DUK_DCERROR_TYPE_INVALID_TRAP_RESULT(thr) do { \
+#define DUK_DCERROR_TYPE_INVALID_TRAP_RESULT(thr) \
+	do { \
 		DUK_ERROR_TYPE((thr), DUK_STR_INVALID_TRAP_RESULT); \
 	} while (0)
-#define DUK_ERROR_TYPE(thr,msg) do { \
+#define DUK_ERROR_TYPE(thr, msg) \
+	do { \
 		DUK_ERROR((thr), DUK_ERR_TYPE_ERROR, (msg)); \
 	} while (0)
-#define DUK_ERROR_URI(thr,msg) do { \
+#define DUK_ERROR_URI(thr, msg) \
+	do { \
 		DUK_ERROR((thr), DUK_ERR_URI_ERROR, (msg)); \
 	} while (0)
-#else  /* DUK_USE_VERBOSE_ERRORS */
+#else /* DUK_USE_VERBOSE_ERRORS */
 /* Non-verbose errors for low memory targets: no file, line, or message. */
 
-#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr,idx,expectname,lowmemstr) do { \
+#define DUK_ERROR_REQUIRE_TYPE_INDEX(thr, idx, expectname, lowmemstr) \
+	do { \
 		duk_err_type((thr)); \
 	} while (0)
 
-#define DUK_ERROR_INTERNAL(thr) do { \
+#define DUK_ERROR_INTERNAL(thr) \
+	do { \
 		duk_err_error((thr)); \
 	} while (0)
-#define DUK_DCERROR_INTERNAL(thr) do { \
+#define DUK_DCERROR_INTERNAL(thr) \
+	do { \
 		DUK_UNREF((thr)); \
 		return DUK_RET_ERROR; \
 	} while (0)
-#define DUK_ERROR_ALLOC_FAILED(thr) do { \
+#define DUK_ERROR_ALLOC_FAILED(thr) \
+	do { \
 		duk_err_error((thr)); \
 	} while (0)
-#define DUK_ERROR_UNSUPPORTED(thr) do { \
+#define DUK_ERROR_UNSUPPORTED(thr) \
+	do { \
 		duk_err_error((thr)); \
 	} while (0)
-#define DUK_DCERROR_UNSUPPORTED(thr) do { \
+#define DUK_DCERROR_UNSUPPORTED(thr) \
+	do { \
 		DUK_UNREF((thr)); \
 		return DUK_RET_ERROR; \
 	} while (0)
-#define DUK_ERROR_ERROR(thr,msg) do { \
+#define DUK_ERROR_ERROR(thr, msg) \
+	do { \
 		duk_err_error((thr)); \
 	} while (0)
-#define DUK_ERROR_RANGE_INDEX(thr,idx) do { \
+#define DUK_ERROR_RANGE_INDEX(thr, idx) \
+	do { \
 		duk_err_range((thr)); \
 	} while (0)
-#define DUK_ERROR_RANGE_PUSH_BEYOND(thr) do { \
+#define DUK_ERROR_RANGE_PUSH_BEYOND(thr) \
+	do { \
 		duk_err_range((thr)); \
 	} while (0)
-#define DUK_ERROR_RANGE_INVALID_ARGS(thr) do { \
+#define DUK_ERROR_RANGE_INVALID_ARGS(thr) \
+	do { \
 		duk_err_range((thr)); \
 	} while (0)
-#define DUK_DCERROR_RANGE_INVALID_ARGS(thr) do { \
+#define DUK_DCERROR_RANGE_INVALID_ARGS(thr) \
+	do { \
 		DUK_UNREF((thr)); \
 		return DUK_RET_RANGE_ERROR; \
 	} while (0)
-#define DUK_ERROR_RANGE_INVALID_COUNT(thr) do { \
+#define DUK_ERROR_RANGE_INVALID_COUNT(thr) \
+	do { \
 		duk_err_range((thr)); \
 	} while (0)
-#define DUK_DCERROR_RANGE_INVALID_COUNT(thr) do { \
+#define DUK_DCERROR_RANGE_INVALID_COUNT(thr) \
+	do { \
 		DUK_UNREF((thr)); \
 		return DUK_RET_RANGE_ERROR; \
 	} while (0)
-#define DUK_ERROR_RANGE_INVALID_LENGTH(thr) do { \
+#define DUK_ERROR_RANGE_INVALID_LENGTH(thr) \
+	do { \
 		duk_err_range((thr)); \
 	} while (0)
-#define DUK_DCERROR_RANGE_INVALID_LENGTH(thr) do { \
+#define DUK_DCERROR_RANGE_INVALID_LENGTH(thr) \
+	do { \
 		DUK_UNREF((thr)); \
 		return DUK_RET_RANGE_ERROR; \
 	} while (0)
-#define DUK_ERROR_RANGE(thr,msg) do { \
+#define DUK_ERROR_RANGE(thr, msg) \
+	do { \
 		duk_err_range((thr)); \
 	} while (0)
-#define DUK_ERROR_EVAL(thr,msg) do { \
+#define DUK_ERROR_EVAL(thr, msg) \
+	do { \
 		duk_err_eval((thr)); \
 	} while (0)
-#define DUK_ERROR_REFERENCE(thr,msg) do { \
+#define DUK_ERROR_REFERENCE(thr, msg) \
+	do { \
 		duk_err_reference((thr)); \
 	} while (0)
-#define DUK_ERROR_SYNTAX(thr,msg) do { \
+#define DUK_ERROR_SYNTAX(thr, msg) \
+	do { \
 		duk_err_syntax((thr)); \
 	} while (0)
-#define DUK_ERROR_TYPE_INVALID_ARGS(thr) do { \
+#define DUK_ERROR_TYPE_INVALID_ARGS(thr) \
+	do { \
 		duk_err_type((thr)); \
 	} while (0)
-#define DUK_DCERROR_TYPE_INVALID_ARGS(thr) do { \
+#define DUK_DCERROR_TYPE_INVALID_ARGS(thr) \
+	do { \
 		DUK_UNREF((thr)); \
 		return DUK_RET_TYPE_ERROR; \
 	} while (0)
-#define DUK_ERROR_TYPE_INVALID_STATE(thr) do { \
+#define DUK_ERROR_TYPE_INVALID_STATE(thr) \
+	do { \
 		duk_err_type((thr)); \
 	} while (0)
-#define DUK_DCERROR_TYPE_INVALID_STATE(thr) do { \
+#define DUK_DCERROR_TYPE_INVALID_STATE(thr) \
+	do { \
 		duk_err_type((thr)); \
 	} while (0)
-#define DUK_ERROR_TYPE_INVALID_TRAP_RESULT(thr) do { \
+#define DUK_ERROR_TYPE_INVALID_TRAP_RESULT(thr) \
+	do { \
 		duk_err_type((thr)); \
 	} while (0)
-#define DUK_DCERROR_TYPE_INVALID_TRAP_RESULT(thr) do { \
+#define DUK_DCERROR_TYPE_INVALID_TRAP_RESULT(thr) \
+	do { \
 		DUK_UNREF((thr)); \
 		return DUK_RET_TYPE_ERROR; \
 	} while (0)
-#define DUK_ERROR_TYPE_INVALID_TRAP_RESULT(thr) do { \
+#define DUK_ERROR_TYPE_INVALID_TRAP_RESULT(thr) \
+	do { \
 		duk_err_type((thr)); \
 	} while (0)
-#define DUK_ERROR_TYPE(thr,msg) do { \
+#define DUK_ERROR_TYPE(thr, msg) \
+	do { \
 		duk_err_type((thr)); \
 	} while (0)
-#define DUK_ERROR_URI(thr,msg) do { \
+#define DUK_ERROR_URI(thr, msg) \
+	do { \
 		duk_err_uri((thr)); \
 	} while (0)
-#endif  /* DUK_USE_VERBOSE_ERRORS */
+#endif /* DUK_USE_VERBOSE_ERRORS */
 
 /*
  *  Assert macro: failure causes a fatal error.
@@ -9913,63 +10567,72 @@
  * we don't care about assertion text size because they're not used in production
  * builds.
  */
-#define DUK_ASSERT(x)  do { \
-	if (!(x)) { \
-		DUK_FATAL_WITHOUT_CONTEXT("assertion failed: " #x \
-			" (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"); \
-	} \
+#define DUK_ASSERT(x) \
+	do { \
+		if (!(x)) { \
+			DUK_FATAL_WITHOUT_CONTEXT("assertion failed: " #x " (" DUK_FILE_MACRO \
+			                          ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"); \
+		} \
 	} while (0)
 
 /* Assertion compatible inside a comma expression, evaluates to void. */
 #define DUK_ASSERT_EXPR(x) \
-	((void) ((x) ? 0 : (DUK_FATAL_WITHOUT_CONTEXT("assertion failed: " #x \
-				" (" DUK_FILE_MACRO ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"), 0)))
+	((void) ((x) ? 0 : \
+                       (DUK_FATAL_WITHOUT_CONTEXT("assertion failed: " #x " (" DUK_FILE_MACRO \
+	                                          ":" DUK_MACRO_STRINGIFY(DUK_LINE_MACRO) ")"), \
+	                0)))
 
-#else  /* DUK_USE_ASSERTIONS */
+#else /* DUK_USE_ASSERTIONS */
 
-#define DUK_ASSERT(x)  do { /* assertion omitted */ } while (0)
+#define DUK_ASSERT(x) \
+	do { /* assertion omitted */ \
+	} while (0)
 
-#define DUK_ASSERT_EXPR(x)  ((void) 0)
+#define DUK_ASSERT_EXPR(x) ((void) 0)
 
-#endif  /* DUK_USE_ASSERTIONS */
+#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)
+#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 { \
+#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 { \
+#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 */
+#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))
+#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 { \
+#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) \
+	do { \
 		duk_double_union duk__assert_tmp_du; \
 		duk__assert_tmp_du.d = (dval); \
 		DUK_ASSERT(DUK_DBLUNION_IS_NORMALIZED(&duk__assert_tmp_du)); \
 	} while (0)
 #else
-#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval)  /* nop */
+#define DUK_ASSERT_DOUBLE_IS_NORMALIZED(dval) /* nop */
 #endif
 
-#define DUK_ASSERT_VS_SPACE(thr) \
-	DUK_ASSERT(thr->valstack_top < thr->valstack_end)
+#define DUK_ASSERT_VS_SPACE(thr) DUK_ASSERT(thr->valstack_top < thr->valstack_end)
 
 /*
  *  Helper to initialize a memory area (e.g. struct) with garbage when
@@ -9977,11 +10640,14 @@
  */
 
 #if defined(DUK_USE_ASSERTIONS)
-#define DUK_ASSERT_SET_GARBAGE(ptr,size) do { \
+#define DUK_ASSERT_SET_GARBAGE(ptr, size) \
+	do { \
 		duk_memset_unsafe((void *) (ptr), 0x5a, size); \
 	} while (0)
 #else
-#define DUK_ASSERT_SET_GARBAGE(ptr,size) do {} while (0)
+#define DUK_ASSERT_SET_GARBAGE(ptr, size) \
+	do { \
+	} while (0)
 #endif
 
 /*
@@ -9992,16 +10658,18 @@
  *  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
-                                       */
+#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 { \
+#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 */
+#define DUK_ASSERT_VALSTACK_SPACE(thr, n) /* no valstack space check */
 #endif
 
 /*
@@ -10009,25 +10677,35 @@
  */
 
 #if defined(DUK_USE_VERBOSE_ERRORS)
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *msg));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error_fmt(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *fmt, ...));
-#else  /* DUK_USE_VERBOSE_ERRORS */
+DUK_NORETURN(
+    DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *msg));
+DUK_NORETURN(DUK_INTERNAL_DECL void
+                 duk_err_handle_error_fmt(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *fmt, ...));
+#else /* DUK_USE_VERBOSE_ERRORS */
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code));
-#endif  /* DUK_USE_VERBOSE_ERRORS */
+#endif /* DUK_USE_VERBOSE_ERRORS */
 
 #if defined(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));
+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));
 
-#define DUK_AUGMENT_FLAG_NOBLAME_FILELINE  (1U << 0)  /* if set, don't blame C file/line for .fileName and .lineNumber */
-#define DUK_AUGMENT_FLAG_SKIP_ONE          (1U << 1)  /* if set, skip topmost activation in traceback construction */
+#define DUK_AUGMENT_FLAG_NOBLAME_FILELINE (1U << 0) /* if set, don't blame C file/line for .fileName and .lineNumber */
+#define DUK_AUGMENT_FLAG_SKIP_ONE         (1U << 1) /* if set, skip topmost activation in traceback construction */
 
 #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_small_uint_t flags);
+DUK_INTERNAL_DECL void duk_err_augment_error_create(duk_hthread *thr,
+                                                    duk_hthread *thr_callstack,
+                                                    const char *filename,
+                                                    duk_int_t line,
+                                                    duk_small_uint_t flags);
 #endif
 #if defined(DUK_USE_AUGMENT_ERROR_THROW)
 DUK_INTERNAL_DECL void duk_err_augment_error_throw(duk_hthread *thr);
@@ -10035,20 +10713,31 @@
 
 #if defined(DUK_USE_VERBOSE_ERRORS)
 #if defined(DUK_USE_PARANOID_ERRORS)
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx, const char *expect_name));
+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr,
+                                                               const char *filename,
+                                                               duk_int_t linenumber,
+                                                               duk_idx_t idx,
+                                                               const char *expect_name));
 #else
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx, const char *expect_name));
+DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_require_type_index(duk_hthread *thr,
+                                                               const char *filename,
+                                                               duk_int_t linenumber,
+                                                               duk_idx_t idx,
+                                                               const char *expect_name));
 #endif
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_error_internal(duk_hthread *thr, const char *filename, duk_int_t linenumber));
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_error_alloc_failed(duk_hthread *thr, const char *filename, duk_int_t linenumber));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_error(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx));
+DUK_NORETURN(
+    DUK_INTERNAL_DECL void duk_err_error(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
+DUK_NORETURN(
+    DUK_INTERNAL_DECL void duk_err_range_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx));
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range_push_beyond(duk_hthread *thr, const char *filename, duk_int_t linenumber));
-DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
+DUK_NORETURN(
+    DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr, const char *filename, duk_int_t linenumber, const char *message));
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type_invalid_args(duk_hthread *thr, const char *filename, duk_int_t linenumber));
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type_invalid_state(duk_hthread *thr, const char *filename, duk_int_t linenumber));
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_type_invalid_trap_result(duk_hthread *thr, const char *filename, duk_int_t linenumber));
-#else  /* DUK_VERBOSE_ERRORS */
+#else /* DUK_VERBOSE_ERRORS */
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_error(duk_hthread *thr));
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_range(duk_hthread *thr));
 DUK_NORETURN(DUK_INTERNAL_DECL void duk_err_eval(duk_hthread *thr));
@@ -10069,7 +10758,7 @@
 
 DUK_INTERNAL_DECL duk_hobject *duk_error_prototype_from_code(duk_hthread *thr, duk_errcode_t err_code);
 
-#endif  /* DUK_ERROR_H_INCLUDED */
+#endif /* DUK_ERROR_H_INCLUDED */
 /* #include duk_unicode.h */
 #line 1 "duk_unicode.h"
 /*
@@ -10083,10 +10772,10 @@
  *  UTF-8 / XUTF-8 / CESU-8 constants
  */
 
-#define DUK_UNICODE_MAX_XUTF8_LENGTH      7   /* up to 36 bit codepoints */
-#define DUK_UNICODE_MAX_XUTF8_BMP_LENGTH  3   /* all codepoints up to U+FFFF */
-#define DUK_UNICODE_MAX_CESU8_LENGTH      6   /* all codepoints up to U+10FFFF */
-#define DUK_UNICODE_MAX_CESU8_BMP_LENGTH  3   /* all codepoints up to U+FFFF */
+#define DUK_UNICODE_MAX_XUTF8_LENGTH     7 /* up to 36 bit codepoints */
+#define DUK_UNICODE_MAX_XUTF8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */
+#define DUK_UNICODE_MAX_CESU8_LENGTH     6 /* all codepoints up to U+10FFFF */
+#define DUK_UNICODE_MAX_CESU8_BMP_LENGTH 3 /* all codepoints up to U+FFFF */
 
 /*
  *  Useful Unicode codepoints
@@ -10095,9 +10784,11 @@
  *  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 */
+#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
@@ -10110,134 +10801,134 @@
  *  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
+#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
 
 /*
  *  Miscellaneous
@@ -10246,7 +10937,7 @@
 /* Uppercase A is 0x41, lowercase a is 0x61; OR 0x20 to convert uppercase
  * to lowercase.
  */
-#define DUK_LOWERCASE_CHAR_ASCII(x)  ((x) | 0x20)
+#define DUK_LOWERCASE_CHAR_ASCII(x) ((x) | 0x20)
 
 /*
  *  Unicode tables
@@ -10334,7 +11025,7 @@
 DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_not_white[24];
 DUK_INTERNAL_DECL const duk_uint16_t duk_unicode_re_ranges_not_wordchar[10];
 DUK_INTERNAL_DECL const duk_int8_t duk_is_idchar_tab[128];
-#endif  /* !DUK_SINGLE_FILE */
+#endif /* !DUK_SINGLE_FILE */
 
 /*
  *  Prototypes
@@ -10346,8 +11037,15 @@
 #endif
 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_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_bool_t duk_unicode_is_utf8_compatible(const duk_uint8_t *buf, duk_size_t len);
 DUK_INTERNAL_DECL duk_small_int_t duk_unicode_is_whitespace(duk_codepoint_t cp);
@@ -10361,7 +11059,7 @@
 DUK_INTERNAL_DECL duk_small_int_t duk_unicode_re_is_wordchar(duk_codepoint_t cp);
 #endif
 
-#endif  /* DUK_UNICODE_H_INCLUDED */
+#endif /* DUK_UNICODE_H_INCLUDED */
 /* #include duk_json.h */
 #line 1 "duk_json.h"
 /*
@@ -10372,28 +11070,28 @@
 #define DUK_JSON_H_INCLUDED
 
 /* Encoding/decoding flags */
-#define DUK_JSON_FLAG_ASCII_ONLY              (1U << 0)  /* escape any non-ASCII characters */
-#define DUK_JSON_FLAG_AVOID_KEY_QUOTES        (1U << 1)  /* avoid key quotes when key is an ASCII Identifier */
-#define DUK_JSON_FLAG_EXT_CUSTOM              (1U << 2)  /* extended types: custom encoding */
-#define DUK_JSON_FLAG_EXT_COMPATIBLE          (1U << 3)  /* extended types: compatible encoding */
+#define DUK_JSON_FLAG_ASCII_ONLY       (1U << 0) /* escape any non-ASCII characters */
+#define DUK_JSON_FLAG_AVOID_KEY_QUOTES (1U << 1) /* avoid key quotes when key is an ASCII Identifier */
+#define DUK_JSON_FLAG_EXT_CUSTOM       (1U << 2) /* extended types: custom encoding */
+#define DUK_JSON_FLAG_EXT_COMPATIBLE   (1U << 3) /* extended types: compatible encoding */
 
 /* How much stack to require on entry to object/array encode */
-#define DUK_JSON_ENC_REQSTACK                 32
+#define DUK_JSON_ENC_REQSTACK 32
 
 /* How much stack to require on entry to object/array decode */
-#define DUK_JSON_DEC_REQSTACK                 32
+#define DUK_JSON_DEC_REQSTACK 32
 
 /* How large a loop detection stack to use */
-#define DUK_JSON_ENC_LOOPARRAY                64
+#define DUK_JSON_ENC_LOOPARRAY 64
 
 /* Encoding state.  Heap object references are all borrowed. */
 typedef struct {
 	duk_hthread *thr;
-	duk_bufwriter_ctx bw;        /* output bufwriter */
-	duk_hobject *h_replacer;     /* replacer function */
-	duk_hstring *h_gap;          /* gap (if empty string, NULL) */
-	duk_idx_t idx_proplist;      /* explicit PropertyList */
-	duk_idx_t idx_loop;          /* valstack index of loop detection object */
+	duk_bufwriter_ctx bw; /* output bufwriter */
+	duk_hobject *h_replacer; /* replacer function */
+	duk_hstring *h_gap; /* gap (if empty string, 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;
@@ -10404,7 +11102,7 @@
 #endif
 	duk_uint_t recursion_depth;
 	duk_uint_t recursion_limit;
-	duk_uint_t mask_for_undefined;      /* type bit mask: types which certainly produce 'undefined' */
+	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;
@@ -10412,7 +11110,7 @@
 	duk_small_uint_t stridx_custom_posinf;
 	duk_small_uint_t stridx_custom_function;
 #endif
-	duk_hobject *visiting[DUK_JSON_ENC_LOOPARRAY];  /* indexed by recursion_depth */
+	duk_hobject *visiting[DUK_JSON_ENC_LOOPARRAY]; /* indexed by recursion_depth */
 } duk_json_enc_ctx;
 
 typedef struct {
@@ -10431,7 +11129,7 @@
 	duk_int_t recursion_limit;
 } duk_json_dec_ctx;
 
-#endif  /* DUK_JSON_H_INCLUDED */
+#endif /* DUK_JSON_H_INCLUDED */
 /* #include duk_js.h */
 #line 1 "duk_js.h"
 /*
@@ -10442,21 +11140,22 @@
 #define DUK_JS_H_INCLUDED
 
 /* Flags for call handling.  Lowest flags must match bytecode DUK_BC_CALL_FLAG_xxx 1:1. */
-#define DUK_CALL_FLAG_TAILCALL                 (1U << 0)  /* setup for a tail call */
-#define DUK_CALL_FLAG_CONSTRUCT                (1U << 1)  /* constructor call (i.e. called as 'new Foo()') */
-#define DUK_CALL_FLAG_CALLED_AS_EVAL           (1U << 2)  /* call was made using the identifier 'eval' */
-#define DUK_CALL_FLAG_ALLOW_ECMATOECMA         (1U << 3)  /* ecma-to-ecma call with executor reuse is possible */
-#define DUK_CALL_FLAG_DIRECT_EVAL              (1U << 4)  /* call is a direct eval call */
-#define DUK_CALL_FLAG_CONSTRUCT_PROXY          (1U << 5)  /* handled via 'construct' proxy trap, check return value invariant(s) */
-#define DUK_CALL_FLAG_DEFAULT_INSTANCE_UPDATED (1U << 6)  /* prototype of 'default instance' updated, temporary flag in call handling */
+#define DUK_CALL_FLAG_TAILCALL         (1U << 0) /* setup for a tail call */
+#define DUK_CALL_FLAG_CONSTRUCT        (1U << 1) /* constructor call (i.e. called as 'new Foo()') */
+#define DUK_CALL_FLAG_CALLED_AS_EVAL   (1U << 2) /* call was made using the identifier 'eval' */
+#define DUK_CALL_FLAG_ALLOW_ECMATOECMA (1U << 3) /* ecma-to-ecma call with executor reuse is possible */
+#define DUK_CALL_FLAG_DIRECT_EVAL      (1U << 4) /* call is a direct eval call */
+#define DUK_CALL_FLAG_CONSTRUCT_PROXY  (1U << 5) /* handled via 'construct' proxy trap, check return value invariant(s) */
+#define DUK_CALL_FLAG_DEFAULT_INSTANCE_UPDATED \
+	(1U << 6) /* prototype of 'default instance' updated, temporary flag in call handling */
 
 /* Flags for duk_js_equals_helper(). */
-#define DUK_EQUALS_FLAG_SAMEVALUE            (1U << 0)  /* use SameValue instead of non-strict equality */
-#define DUK_EQUALS_FLAG_STRICT               (1U << 1)  /* use strict equality instead of non-strict equality */
+#define DUK_EQUALS_FLAG_SAMEVALUE (1U << 0) /* use SameValue instead of non-strict equality */
+#define DUK_EQUALS_FLAG_STRICT    (1U << 1) /* use strict equality instead of non-strict equality */
 
 /* Flags for duk_js_compare_helper(). */
-#define DUK_COMPARE_FLAG_NEGATE              (1U << 0)  /* negate result */
-#define DUK_COMPARE_FLAG_EVAL_LEFT_FIRST     (1U << 1)  /* eval left argument first */
+#define DUK_COMPARE_FLAG_NEGATE          (1U << 0) /* negate result */
+#define DUK_COMPARE_FLAG_EVAL_LEFT_FIRST (1U << 1) /* eval left argument first */
 
 /* conversions, coercions, comparison, etc */
 DUK_INTERNAL_DECL duk_bool_t duk_js_toboolean(duk_tval *tv);
@@ -10472,9 +11171,12 @@
 DUK_INTERNAL_DECL duk_uarridx_t duk_js_to_arrayindex_hstring_fast(duk_hstring *h);
 #endif
 DUK_INTERNAL_DECL duk_bool_t duk_js_equals_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_t flags);
-DUK_INTERNAL_DECL duk_small_int_t duk_js_data_compare(const duk_uint8_t *buf1, const duk_uint8_t *buf2, duk_size_t len1, duk_size_t len2);
+DUK_INTERNAL_DECL duk_small_int_t duk_js_data_compare(const duk_uint8_t *buf1,
+                                                      const duk_uint8_t *buf2,
+                                                      duk_size_t len1,
+                                                      duk_size_t len2);
 DUK_INTERNAL_DECL duk_small_int_t duk_js_string_compare(duk_hstring *h1, duk_hstring *h2);
-#if 0  /* unused */
+#if 0 /* unused */
 DUK_INTERNAL_DECL duk_small_int_t duk_js_buffer_compare(duk_heap *heap, duk_hbuffer *h1, duk_hbuffer *h2);
 #endif
 DUK_INTERNAL_DECL duk_bool_t duk_js_compare_helper(duk_hthread *thr, duk_tval *tv_x, duk_tval *tv_y, duk_small_uint_t flags);
@@ -10491,45 +11193,57 @@
 DUK_INTERNAL_DECL double duk_js_arith_pow(double x, double y);
 DUK_INTERNAL_DECL double duk_js_arith_mod(double x, double y);
 
-#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)
+#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)
+#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)
+#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)
+#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) \
+#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*/
+#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_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_uint_t prop_flags, duk_bool_t is_func_decl);
+DUK_INTERNAL_DECL duk_bool_t duk_js_declvar_activation(duk_hthread *thr,
+                                                       duk_activation *act,
+                                                       duk_hstring *name,
+                                                       duk_tval *val,
+                                                       duk_small_uint_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_INTERNAL_DECL duk_hobject *duk_create_activation_environment_record(duk_hthread *thr, duk_hobject *func, duk_size_t bottom_byteoff);
+DUK_INTERNAL_DECL duk_hobject *duk_create_activation_environment_record(duk_hthread *thr,
+                                                                        duk_hobject *func,
+                                                                        duk_size_t bottom_byteoff);
 DUK_INTERNAL_DECL void duk_js_push_closure(duk_hthread *thr,
                                            duk_hcompfunc *fun_temp,
                                            duk_hobject *outer_var_env,
@@ -10540,7 +11254,8 @@
 DUK_INTERNAL_DECL void duk_native_stack_check(duk_hthread *thr);
 DUK_INTERNAL_DECL duk_int_t duk_handle_call_unprotected(duk_hthread *thr, duk_idx_t idx_func, duk_small_uint_t call_flags);
 DUK_INTERNAL_DECL duk_int_t duk_handle_call_unprotected_nargs(duk_hthread *thr, duk_idx_t nargs, duk_small_uint_t call_flags);
-DUK_INTERNAL_DECL duk_int_t duk_handle_safe_call(duk_hthread *thr, duk_safe_call_function func, void *udata, duk_idx_t num_stack_args, duk_idx_t num_stack_res);
+DUK_INTERNAL_DECL duk_int_t
+duk_handle_safe_call(duk_hthread *thr, duk_safe_call_function func, void *udata, duk_idx_t num_stack_args, duk_idx_t num_stack_res);
 DUK_INTERNAL_DECL void duk_call_construct_postprocess(duk_hthread *thr, duk_small_uint_t proxy_invariant);
 #if defined(DUK_USE_VERBOSE_ERRORS)
 DUK_INTERNAL_DECL void duk_call_setup_propcall_error(duk_hthread *thr, duk_tval *tv_base, duk_tval *tv_key);
@@ -10549,7 +11264,7 @@
 /* bytecode execution */
 DUK_INTERNAL_DECL void duk_js_execute_bytecode(duk_hthread *exec_thr);
 
-#endif  /* DUK_JS_H_INCLUDED */
+#endif /* DUK_JS_H_INCLUDED */
 /* #include duk_numconv.h */
 #line 1 "duk_numconv.h"
 /*
@@ -10563,23 +11278,23 @@
 /* Output a specified number of digits instead of using the shortest
  * form.  Used for toPrecision() and toFixed().
  */
-#define DUK_N2S_FLAG_FIXED_FORMAT         (1U << 0)
+#define DUK_N2S_FLAG_FIXED_FORMAT (1U << 0)
 
 /* Force exponential format.  Used for toExponential(). */
-#define DUK_N2S_FLAG_FORCE_EXP            (1U << 1)
+#define DUK_N2S_FLAG_FORCE_EXP (1U << 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          (1U << 2)
+#define DUK_N2S_FLAG_NO_ZERO_PAD (1U << 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      (1U << 3)
+#define DUK_N2S_FLAG_FRACTION_DIGITS (1U << 3)
 
 /*
  *  String-to-number conversion
@@ -10593,69 +11308,72 @@
  * radix 10, but with maximum radix (36) a safe limit is:
  * (10000000*36).toString(16) -> '15752a00'
  */
-#define DUK_S2N_MAX_EXPONENT              10000000L
+#define DUK_S2N_MAX_EXPONENT 10000000L
 
 /* Trim white space (= allow leading and trailing whitespace) */
-#define DUK_S2N_FLAG_TRIM_WHITE           (1U << 0)
+#define DUK_S2N_FLAG_TRIM_WHITE (1U << 0)
 
 /* Allow exponent */
-#define DUK_S2N_FLAG_ALLOW_EXP            (1U << 1)
+#define DUK_S2N_FLAG_ALLOW_EXP (1U << 1)
 
 /* Allow trailing garbage (e.g. treat "123foo" as "123) */
-#define DUK_S2N_FLAG_ALLOW_GARBAGE        (1U << 2)
+#define DUK_S2N_FLAG_ALLOW_GARBAGE (1U << 2)
 
 /* Allow leading plus sign */
-#define DUK_S2N_FLAG_ALLOW_PLUS           (1U << 3)
+#define DUK_S2N_FLAG_ALLOW_PLUS (1U << 3)
 
 /* Allow leading minus sign */
-#define DUK_S2N_FLAG_ALLOW_MINUS          (1U << 4)
+#define DUK_S2N_FLAG_ALLOW_MINUS (1U << 4)
 
 /* Allow 'Infinity' */
-#define DUK_S2N_FLAG_ALLOW_INF            (1U << 5)
+#define DUK_S2N_FLAG_ALLOW_INF (1U << 5)
 
 /* Allow fraction part */
-#define DUK_S2N_FLAG_ALLOW_FRAC           (1U << 6)
+#define DUK_S2N_FLAG_ALLOW_FRAC (1U << 6)
 
 /* Allow naked fraction (e.g. ".123") */
-#define DUK_S2N_FLAG_ALLOW_NAKED_FRAC     (1U << 7)
+#define DUK_S2N_FLAG_ALLOW_NAKED_FRAC (1U << 7)
 
 /* Allow empty fraction (e.g. "123.") */
-#define DUK_S2N_FLAG_ALLOW_EMPTY_FRAC     (1U << 8)
+#define DUK_S2N_FLAG_ALLOW_EMPTY_FRAC (1U << 8)
 
 /* Allow empty string to be interpreted as 0 */
-#define DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO  (1U << 9)
+#define DUK_S2N_FLAG_ALLOW_EMPTY_AS_ZERO (1U << 9)
 
 /* Allow leading zeroes (e.g. "0123" -> "123") */
-#define DUK_S2N_FLAG_ALLOW_LEADING_ZERO   (1U << 10)
+#define DUK_S2N_FLAG_ALLOW_LEADING_ZERO (1U << 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   (1U << 11)
+#define DUK_S2N_FLAG_ALLOW_AUTO_HEX_INT (1U << 11)
 
 /* Allow automatic detection of legacy octal base ("0n"),
  * overrides radix argument and forces integer mode.
  */
-#define DUK_S2N_FLAG_ALLOW_AUTO_LEGACY_OCT_INT   (1U << 12)
+#define DUK_S2N_FLAG_ALLOW_AUTO_LEGACY_OCT_INT (1U << 12)
 
 /* Allow automatic detection of ES2015 octal base ("0o123"),
  * overrides radix argument and forces integer mode.
  */
-#define DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT   (1U << 13)
+#define DUK_S2N_FLAG_ALLOW_AUTO_OCT_INT (1U << 13)
 
 /* Allow automatic detection of ES2015 binary base ("0b10001"),
  * overrides radix argument and forces integer mode.
  */
-#define DUK_S2N_FLAG_ALLOW_AUTO_BIN_INT   (1U << 14)
+#define DUK_S2N_FLAG_ALLOW_AUTO_BIN_INT (1U << 14)
 
 /*
  *  Prototypes
  */
 
-DUK_INTERNAL_DECL void duk_numconv_stringify(duk_hthread *thr, duk_small_int_t radix, duk_small_int_t digits, duk_small_uint_t flags);
+DUK_INTERNAL_DECL void duk_numconv_stringify(duk_hthread *thr,
+                                             duk_small_int_t radix,
+                                             duk_small_int_t digits,
+                                             duk_small_uint_t flags);
 DUK_INTERNAL_DECL void duk_numconv_parse(duk_hthread *thr, duk_small_int_t radix, duk_small_uint_t flags);
 
-#endif  /* DUK_NUMCONV_H_INCLUDED */
+#endif /* DUK_NUMCONV_H_INCLUDED */
 /* #include duk_bi_protos.h */
 #line 1 "duk_bi_protos.h"
 /*
@@ -10672,7 +11390,7 @@
  *   32
  * Include additional space to be safe.
  */
-#define  DUK_BI_DATE_ISO8601_BUFSIZE  40
+#define DUK_BI_DATE_ISO8601_BUFSIZE 40
 
 /* Helpers exposed for internal use */
 DUK_INTERNAL_DECL void duk_bi_date_timeval_to_parts(duk_double_t d, duk_int_t *parts, duk_double_t *dparts, duk_small_uint_t flags);
@@ -10710,7 +11428,10 @@
 DUK_INTERNAL_DECL duk_bool_t duk_bi_date_parse_string_getdate(duk_hthread *thr, const char *str);
 #endif
 #if defined(DUK_USE_DATE_FMT_STRFTIME)
-DUK_INTERNAL_DECL duk_bool_t duk_bi_date_format_parts_strftime(duk_hthread *thr, duk_int_t *parts, duk_int_t tzoffset, duk_small_uint_t flags);
+DUK_INTERNAL_DECL duk_bool_t duk_bi_date_format_parts_strftime(duk_hthread *thr,
+                                                               duk_int_t *parts,
+                                                               duk_int_t tzoffset,
+                                                               duk_small_uint_t flags);
 #endif
 
 #if defined(DUK_USE_GET_MONOTONIC_TIME_CLOCK_GETTIME)
@@ -10721,10 +11442,7 @@
 #endif
 
 DUK_INTERNAL_DECL
-void duk_bi_json_parse_helper(duk_hthread *thr,
-                              duk_idx_t idx_value,
-                              duk_idx_t idx_reviver,
-                              duk_small_uint_t flags);
+void duk_bi_json_parse_helper(duk_hthread *thr, 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_hthread *thr,
                                   duk_idx_t idx_value,
@@ -10738,7 +11456,7 @@
 DUK_INTERNAL_DECL void duk_proxy_ownkeys_postprocess(duk_hthread *thr, duk_hobject *h_proxy_target, duk_uint_t flags);
 #endif
 
-#endif  /* DUK_BUILTIN_PROTOS_H_INCLUDED */
+#endif /* DUK_BUILTIN_PROTOS_H_INCLUDED */
 /* #include duk_selftest.h */
 #line 1 "duk_selftest.h"
 /*
@@ -10755,10 +11473,10 @@
                                                     void *udata);
 #endif
 
-#endif  /* DUK_SELFTEST_H_INCLUDED */
+#endif /* DUK_SELFTEST_H_INCLUDED */
 #line 76 "duk_internal.h"
 
-#endif  /* DUK_INTERNAL_H_INCLUDED */
+#endif /* DUK_INTERNAL_H_INCLUDED */
 #line 10 "duk_replacements.c"
 
 #if defined(DUK_USE_COMPUTED_NAN)
@@ -10854,7 +11572,7 @@
 #error debugging enabled (DUK_USE_DEBUG) but DUK_USE_DEBUG_WRITE not defined
 #endif
 
-#define DUK__DEBUG_BUFSIZE  DUK_USE_DEBUG_BUFSIZE
+#define DUK__DEBUG_BUFSIZE DUK_USE_DEBUG_BUFSIZE
 
 #if defined(DUK_USE_VARIADIC_MACROS)
 
@@ -10882,7 +11600,7 @@
 	va_end(ap);
 }
 
-#else  /* DUK_USE_VARIADIC_MACROS */
+#else /* DUK_USE_VARIADIC_MACROS */
 
 DUK_INTERNAL char duk_debug_file_stash[DUK_DEBUG_STASH_SIZE];
 DUK_INTERNAL duk_int_t duk_debug_line_stash;
@@ -10913,15 +11631,15 @@
 	va_end(ap);
 }
 
-#endif  /* DUK_USE_VARIADIC_MACROS */
+#endif /* DUK_USE_VARIADIC_MACROS */
 
-#else  /* DUK_USE_DEBUG */
+#else /* DUK_USE_DEBUG */
 
 /*
  *  Debugging disabled
  */
 
-#endif  /* DUK_USE_DEBUG */
+#endif /* DUK_USE_DEBUG */
 
 /* automatic undefs */
 #undef DUK__DEBUG_BUFSIZE
@@ -11291,7 +12009,7 @@
 137,194,70,46,142,68,165,19,236,1,64,174,187,161,95,37,134,204,23,225,35,
 23,71,34,82,137,246,128,160,89,93,208,167,147,195,201,194,70,46,142,68,165,
 19,238,1,64,182,187,161,71,105,20,19,177,139,163,145,41,68,16,7,6,15,82,70,
-72,115,96,0,0,0,0,0,15,106,32,91,60,165,195,201,194,8,134,149,216,162,0,
+72,115,96,0,0,0,0,0,27,234,32,91,60,165,195,201,194,8,134,149,216,162,0,
 192,41,225,8,2,48,177,36,1,149,13,196,15,0,200,209,97,199,128,99,32,176,
 195,192,113,57,143,0,167,133,32,230,80,28,202,139,175,238,2,48,189,192,20,
 1,119,80,87,193,186,129,89,56,72,197,209,200,193,185,35,23,71,109,13,219,
@@ -11491,7 +12209,7 @@
 137,194,70,46,142,68,165,19,236,1,64,174,187,161,95,37,134,204,23,225,35,
 23,71,34,82,137,246,128,160,89,93,208,167,147,195,201,194,70,46,142,68,165,
 19,238,1,64,182,187,161,71,105,20,19,177,139,163,145,41,68,16,7,6,15,82,70,
-72,115,96,32,106,15,0,0,0,0,0,91,60,165,195,201,194,8,134,149,216,162,0,
+72,115,96,32,106,27,128,0,0,0,0,91,60,165,195,201,194,8,134,149,216,162,0,
 192,41,225,8,2,48,177,36,1,149,13,196,15,0,200,209,97,199,128,99,32,176,
 195,192,113,57,143,0,167,133,32,230,80,28,202,139,175,238,2,48,189,192,20,
 1,119,80,87,193,186,129,89,56,72,197,209,200,193,185,35,23,71,109,13,219,
@@ -11691,7 +12409,7 @@
 137,194,70,46,142,68,165,19,236,1,64,174,187,161,95,37,134,204,23,225,35,
 23,71,34,82,137,246,128,160,89,93,208,167,147,195,201,194,70,46,142,68,165,
 19,238,1,64,182,187,161,71,105,20,19,177,139,163,145,41,68,16,7,6,15,82,70,
-72,115,96,0,15,106,32,0,0,0,0,91,60,165,195,201,194,8,134,149,216,162,0,
+72,115,96,0,27,234,32,0,0,0,0,91,60,165,195,201,194,8,134,149,216,162,0,
 192,41,225,8,2,48,177,36,1,149,13,196,15,0,200,209,97,199,128,99,32,176,
 195,192,113,57,143,0,167,133,32,230,80,28,202,139,175,238,2,48,189,192,20,
 1,119,80,87,193,186,129,89,56,72,197,209,200,193,185,35,23,71,109,13,219,
@@ -11797,31 +12515,43 @@
 
 /* #include duk_internal.h -> already included */
 
-#define DUK__ERRFMT_BUFSIZE  256  /* size for formatting buffers */
+#define DUK__ERRFMT_BUFSIZE 256 /* size for formatting buffers */
 
 #if defined(DUK_USE_VERBOSE_ERRORS)
 
-DUK_INTERNAL DUK_COLD void duk_err_handle_error_fmt(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *fmt, ...) {
+DUK_INTERNAL DUK_COLD void duk_err_handle_error_fmt(duk_hthread *thr,
+                                                    const char *filename,
+                                                    duk_uint_t line_and_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, (duk_errcode_t) (line_and_code >> 24), msg, filename, (duk_int_t) (line_and_code & 0x00ffffffL));
-	va_end(ap);  /* dead code, but ensures portability (see Linux man page notes) */
+	duk_err_create_and_throw(thr,
+	                         (duk_errcode_t) (line_and_code >> 24),
+	                         msg,
+	                         filename,
+	                         (duk_int_t) (line_and_code & 0x00ffffffL));
+	va_end(ap); /* dead code, but ensures portability (see Linux man page notes) */
 }
 
 DUK_INTERNAL DUK_COLD void duk_err_handle_error(duk_hthread *thr, const char *filename, duk_uint_t line_and_code, const char *msg) {
-	duk_err_create_and_throw(thr, (duk_errcode_t) (line_and_code >> 24), msg, filename, (duk_int_t) (line_and_code & 0x00ffffffL));
+	duk_err_create_and_throw(thr,
+	                         (duk_errcode_t) (line_and_code >> 24),
+	                         msg,
+	                         filename,
+	                         (duk_int_t) (line_and_code & 0x00ffffffL));
 }
 
-#else  /* DUK_USE_VERBOSE_ERRORS */
+#else /* DUK_USE_VERBOSE_ERRORS */
 
 DUK_INTERNAL DUK_COLD void duk_err_handle_error(duk_hthread *thr, duk_errcode_t code) {
 	duk_err_create_and_throw(thr, code);
 }
 
-#endif  /* DUK_USE_VERBOSE_ERRORS */
+#endif /* DUK_USE_VERBOSE_ERRORS */
 
 /*
  *  Error throwing helpers
@@ -11829,14 +12559,34 @@
 
 #if defined(DUK_USE_VERBOSE_ERRORS)
 #if defined(DUK_USE_PARANOID_ERRORS)
-DUK_INTERNAL DUK_COLD void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx, const char *expect_name) {
-	DUK_ERROR_RAW_FMT3(thr, filename, linenumber, DUK_ERR_TYPE_ERROR, "%s required, found %s (stack index %ld)",
-	                   expect_name, duk_get_type_name(thr, idx), (long) idx);
+DUK_INTERNAL DUK_COLD void duk_err_require_type_index(duk_hthread *thr,
+                                                      const char *filename,
+                                                      duk_int_t linenumber,
+                                                      duk_idx_t idx,
+                                                      const char *expect_name) {
+	DUK_ERROR_RAW_FMT3(thr,
+	                   filename,
+	                   linenumber,
+	                   DUK_ERR_TYPE_ERROR,
+	                   "%s required, found %s (stack index %ld)",
+	                   expect_name,
+	                   duk_get_type_name(thr, idx),
+	                   (long) idx);
 }
 #else
-DUK_INTERNAL DUK_COLD void duk_err_require_type_index(duk_hthread *thr, const char *filename, duk_int_t linenumber, duk_idx_t idx, const char *expect_name) {
-	DUK_ERROR_RAW_FMT3(thr, filename, linenumber, DUK_ERR_TYPE_ERROR, "%s required, found %s (stack index %ld)",
-	                   expect_name, duk_push_string_readable(thr, idx), (long) idx);
+DUK_INTERNAL DUK_COLD void duk_err_require_type_index(duk_hthread *thr,
+                                                      const char *filename,
+                                                      duk_int_t linenumber,
+                                                      duk_idx_t idx,
+                                                      const char *expect_name) {
+	DUK_ERROR_RAW_FMT3(thr,
+	                   filename,
+	                   linenumber,
+	                   DUK_ERR_TYPE_ERROR,
+	                   "%s required, found %s (stack index %ld)",
+	                   expect_name,
+	                   duk_push_string_readable(thr, idx),
+	                   (long) idx);
 }
 #endif
 DUK_INTERNAL DUK_COLD void duk_err_error_internal(duk_hthread *thr, const char *filename, duk_int_t linenumber) {
@@ -11964,14 +12714,14 @@
 	 * 1: IdentifierStart and IdentifierPart
 	 * -1: IdentifierPart only
 	 */
-	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x00...0x0f */
-	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x10...0x1f */
-	0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x20...0x2f */
-	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0,  0,  0,  0,  0,  0,   /* 0x30...0x3f */
-	0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,   /* 0x40...0x4f */
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  1,   /* 0x50...0x5f */
-	0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,   /* 0x60...0x6f */
-	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  0,  0,  0,  0,  0    /* 0x70...0x7f */
+	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, /* 0x00...0x0f */
+	0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, /* 0x10...0x1f */
+	0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0, 0, 0, 0, 0, 0, /* 0x20...0x2f */
+	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, /* 0x30...0x3f */
+	0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 1, 1, 1, 1, 1, /* 0x40...0x4f */
+	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 0, 0, 0, 0, 1, /* 0x50...0x5f */
+	0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 1, 1, 1, 1, 1, /* 0x60...0x6f */
+	1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, 0, 0, 0, 0, 0 /* 0x70...0x7f */
 };
 #endif
 
@@ -12021,15 +12771,13 @@
 		/* Encoded as surrogate pair, each encoding to 3 bytes for
 		 * 6 bytes total.  Codepoints above U+10FFFF encode as 6 bytes
 		 * too, see duk_unicode_encode_cesu8().
-		  */
+		 */
 		return 3 + 3;
 	}
 }
-#endif  /* DUK_USE_ASSERTIONS */
+#endif /* DUK_USE_ASSERTIONS */
 
-DUK_INTERNAL const duk_uint8_t duk_unicode_xutf8_markers[7] = {
-	0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe
-};
+DUK_INTERNAL const 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
@@ -12044,7 +12792,7 @@
 	len = duk_unicode_get_xutf8_length(cp);
 	DUK_ASSERT(len > 0);
 
-	marker = duk_unicode_xutf8_markers[len - 1];  /* 64-bit OK because always >= 0 */
+	marker = duk_unicode_xutf8_markers[len - 1]; /* 64-bit OK because always >= 0 */
 
 	i = len;
 	DUK_ASSERT(i > 0);
@@ -12129,7 +12877,11 @@
 }
 
 /* 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) {
+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;
@@ -12191,7 +12943,7 @@
 		goto fail;
 	}
 
-	DUK_ASSERT(p >= ptr_start);  /* verified at beginning */
+	DUK_ASSERT(p >= ptr_start); /* verified at beginning */
 	if (p + n > ptr_end) {
 		/* check pointer at end */
 		goto fail;
@@ -12217,12 +12969,15 @@
 	*out_cp = res;
 	return 1;
 
- fail:
+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_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)) {
@@ -12269,7 +13024,7 @@
 	DUK_ASSERT(clen <= blen);
 	return clen;
 }
-#else  /* DUK_USE_PREFER_SIZE */
+#else /* DUK_USE_PREFER_SIZE */
 /* This seems like a good overall approach.  Fast path for ASCII in 4 byte
  * blocks.
  */
@@ -12281,7 +13036,7 @@
 	duk_size_t ncont;
 	duk_size_t clen;
 
-	ncont = 0;  /* number of continuation (non-initial) bytes in [0x80,0xbf] */
+	ncont = 0; /* number of continuation (non-initial) bytes in [0x80,0xbf] */
 	p = data;
 	p_end = data + blen;
 	if (blen < 16) {
@@ -12306,7 +13061,7 @@
 		duk_uint32_t x;
 		x = *p32++;
 		if (DUK_LIKELY((x & 0x80808080UL) == 0)) {
-			;  /* ASCII fast path */
+			; /* ASCII fast path */
 		} else {
 			/* Flip highest bit of each byte which changes
 			 * the bit pattern 10xxxxxx into 00xxxxxx which
@@ -12330,7 +13085,7 @@
 	p = (const duk_uint8_t *) p32;
 	/* Fall through to handle the rest. */
 
- skip_fastpath:
+skip_fastpath:
 	while (p != p_end) {
 		duk_uint8_t x;
 		x = *p++;
@@ -12344,7 +13099,7 @@
 	DUK_ASSERT(clen <= blen);
 	return clen;
 }
-#endif  /* DUK_USE_PREFER_SIZE */
+#endif /* DUK_USE_PREFER_SIZE */
 
 /* Check whether a string is UTF-8 compatible or not. */
 DUK_INTERNAL duk_bool_t duk_unicode_is_utf8_compatible(const duk_uint8_t *buf, duk_size_t len) {
@@ -12393,18 +13148,18 @@
 		 * 1111 0xxx + 3*CONT -> [0x10000, 0x10ffff]
 		 */
 		left = len - i;
-		if (t <= 0xdfU) {  /* 1101 1111 = 0xdf */
-			if (t <= 0xbfU) {  /* 1011 1111 = 0xbf */
+		if (t <= 0xdfU) { /* 1101 1111 = 0xdf */
+			if (t <= 0xbfU) { /* 1011 1111 = 0xbf */
 				return 0;
 			}
 			ncont = 1;
 			mincp = 0x80UL;
 			cp = t & 0x1fU;
-		} else if (t <= 0xefU) {  /* 1110 1111 = 0xef */
+		} else if (t <= 0xefU) { /* 1110 1111 = 0xef */
 			ncont = 2;
 			mincp = 0x800UL;
 			cp = t & 0x0fU;
-		} else if (t <= 0xf7U) {  /* 1111 0111 = 0xf7 */
+		} else if (t <= 0xf7U) { /* 1111 0111 = 0xf7 */
 			ncont = 3;
 			mincp = 0x10000UL;
 			cp = t & 0x07U;
@@ -12416,7 +13171,7 @@
 		}
 		while (ncont > 0U) {
 			t = buf[i++];
-			if ((t & 0xc0U) != 0x80U) {  /* 10xx xxxx */
+			if ((t & 0xc0U) != 0x80U) { /* 10xx xxxx */
 				return 0;
 			}
 			cp = (cp << 6) + (t & 0x3fU);
@@ -12482,7 +13237,9 @@
 		/* [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));
+		                     (unsigned long) cp,
+		                     (unsigned long) r1,
+		                     (unsigned long) r2));
 		if (cp >= r1 && cp <= r2) {
 			return 1;
 		}
@@ -12552,19 +13309,17 @@
 	/* 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 */
+	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) {
+		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) {
+	} else if (cp == 0x1680L || cp == 0x180eL || cp == 0x3000L || cp == 0xfeffL) {
 		return 1;
 	}
 
@@ -12583,8 +13338,7 @@
 	 *  into a single line terminator.  This must be handled by the caller.
 	 */
 
-	if (cp == 0x000aL || cp == 0x000dL || cp == 0x2028L ||
-	    cp == 0x2029L) {
+	if (cp == 0x000aL || cp == 0x000dL || cp == 0x2028L || cp == 0x2029L) {
 		return 1;
 	}
 
@@ -12635,9 +13389,7 @@
 #if defined(DUK_USE_IDCHAR_FASTPATH)
 		return (cp >= 0) && (duk_is_idchar_tab[cp] > 0);
 #else
-		if ((cp >= 'a' && cp <= 'z') ||
-		    (cp >= 'A' && cp <= 'Z') ||
-		    cp == '_' || cp == '$') {
+		if ((cp >= 'a' && cp <= 'z') || (cp >= 'A' && cp <= 'Z') || cp == '_' || cp == '$') {
 			return 1;
 		}
 		return 0;
@@ -12647,17 +13399,13 @@
 	/* Non-ASCII slow path (range-by-range linear comparison), very slow */
 
 #if defined(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)) {
+	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)) {
+		if (duk__uni_range_match(duk_unicode_ids_noabmp, sizeof(duk_unicode_ids_noabmp), (duk_codepoint_t) cp)) {
 			return 1;
 		}
 		return 0;
@@ -12724,10 +13472,7 @@
 #if defined(DUK_USE_IDCHAR_FASTPATH)
 		return (cp >= 0) && (duk_is_idchar_tab[cp] != 0);
 #else
-		if ((cp >= 'a' && cp <= 'z') ||
-		    (cp >= 'A' && cp <= 'Z') ||
-		    (cp >= '0' && cp <= '9') ||
-		    cp == '_' || cp == '$') {
+		if ((cp >= 'a' && cp <= 'z') || (cp >= 'A' && cp <= 'Z') || (cp >= '0' && cp <= '9') || cp == '_' || cp == '$') {
 			return 1;
 		}
 		return 0;
@@ -12737,20 +13482,14 @@
 	/* Non-ASCII slow path (range-by-range linear comparison), very slow */
 
 #if defined(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)) {
+	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) ||
+		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)) {
@@ -12786,8 +13525,7 @@
 
 	/* ASCII (and EOF) fast path -- quick accept and reject */
 	if (cp <= 0x7fL) {
-		if ((cp >= 'a' && cp <= 'z') ||
-		    (cp >= 'A' && cp <= 'Z')) {
+		if ((cp >= 'a' && cp <= 'z') || (cp >= 'A' && cp <= 'Z')) {
 			return 1;
 		}
 		return 0;
@@ -12796,20 +13534,14 @@
 	/* Non-ASCII slow path (range-by-range linear comparison), very slow */
 
 #if defined(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)) {
+	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) &&
+		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)) {
@@ -12846,10 +13578,7 @@
  */
 
 DUK_LOCAL
-duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr,
-                                          duk_bufwriter_ctx *bw,
-                                          duk_codepoint_t cp,
-                                          duk_bitdecoder_ctx *bd_ctx) {
+duk_codepoint_t duk__slow_case_conversion(duk_hthread *thr, duk_bufwriter_ctx *bw, 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;
@@ -12879,10 +13608,13 @@
 			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));
+			                     (long) start_i,
+			                     (long) start_o,
+			                     (long) count,
+			                     (long) skip));
 
 			if (cp >= start_i) {
-				tmp_cp = cp - start_i;  /* always >= 0 */
+				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"));
@@ -12934,7 +13666,7 @@
 	DUK_DDD(DUK_DDDPRINT("no rule matches, output is same as input"));
 	/* fall through */
 
- single:
+single:
 	if (bw != NULL) {
 		DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp);
 	}
@@ -12996,9 +13728,9 @@
 		 *  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 */
+		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
@@ -13024,13 +13756,13 @@
 	}
 	return duk__slow_case_conversion(thr, bw, cp, &bd_ctx);
 
- singlechar:
+singlechar:
 	if (bw != NULL) {
 		DUK_BW_WRITE_RAW_XUTF8(thr, bw, (duk_ucodepoint_t) cp);
 	}
 	return cp;
 
- /* unused now, not needed until Turkish/Azeri */
+	/* unused now, not needed until Turkish/Azeri */
 #if 0
  nochar:
 	return -1;
@@ -13048,7 +13780,7 @@
 	const duk_uint8_t *p, *p_start, *p_end;
 	duk_codepoint_t prev, curr, next;
 
-	h_input = duk_require_hstring(thr, -1);  /* Accept symbols. */
+	h_input = duk_require_hstring(thr, -1); /* Accept symbols. */
 	DUK_ASSERT(h_input != NULL);
 
 	bw = &bw_alloc;
@@ -13060,7 +13792,8 @@
 	p_end = p_start + DUK_HSTRING_GET_BYTELEN(h_input);
 	p = p_start;
 
-	prev = -1; DUK_UNREF(prev);
+	prev = -1;
+	DUK_UNREF(prev);
 	curr = -1;
 	next = -1;
 	for (;;) {
@@ -13085,17 +13818,12 @@
 			/* Ensure space for maximum multi-character result; estimate is overkill. */
 			DUK_BW_ENSURE(thr, bw, 8 * DUK_UNICODE_MAX_XUTF8_LENGTH);
 
-			duk__case_transform_helper(thr,
-			                           bw,
-			                           (duk_codepoint_t) curr,
-			                           prev,
-			                           next,
-			                           uppercase);
+			duk__case_transform_helper(thr, bw, (duk_codepoint_t) curr, prev, next, uppercase);
 		}
 	}
 
 	DUK_BW_COMPACT(thr, bw);
-	(void) duk_buffer_to_string(thr, -1);  /* Safe, output is encoded. */
+	(void) duk_buffer_to_string(thr, -1); /* Safe, output is encoded. */
 	/* invalidates h_buf pointer */
 	duk_remove_m2(thr);
 }
@@ -13118,15 +13846,15 @@
 		return (duk_codepoint_t) duk_unicode_re_canon_lookup[cp];
 	}
 	return cp;
-#else  /* DUK_USE_REGEXP_CANON_WORKAROUND */
+#else /* DUK_USE_REGEXP_CANON_WORKAROUND */
 	duk_codepoint_t y;
 
 	y = duk__case_transform_helper(thr,
-	                               NULL,    /* NULL is allowed, no output */
-	                               cp,      /* curr char */
-	                               -1,      /* prev char */
-	                               -1,      /* next char */
-	                               1);      /* uppercase */
+	                               NULL, /* NULL is allowed, no output */
+	                               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
@@ -13136,7 +13864,7 @@
 	}
 
 	return y;
-#endif  /* DUK_USE_REGEXP_CANON_WORKAROUND */
+#endif /* DUK_USE_REGEXP_CANON_WORKAROUND */
 }
 
 /*
@@ -13149,10 +13877,7 @@
 	 *  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 == '_')) {
+	if ((x >= '0' && x <= '9') || (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z') || (x == '_')) {
 		return 1;
 	}
 	return 0;
@@ -13164,54 +13889,39 @@
 
 /* exposed because lexer needs these too */
 DUK_INTERNAL const duk_uint16_t duk_unicode_re_ranges_digit[2] = {
-	(duk_uint16_t) 0x0030UL, (duk_uint16_t) 0x0039UL,
+	(duk_uint16_t) 0x0030UL,
+	(duk_uint16_t) 0x0039UL,
 };
 DUK_INTERNAL const 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) 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 const 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_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 const 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_uint16_t) 0x0000UL,
+	(duk_uint16_t) 0x002FUL,
+	(duk_uint16_t) 0x003AUL,
+	(duk_uint16_t) 0xFFFFUL,
 };
 DUK_INTERNAL const 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_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 const 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,
+	(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 */
+#endif /* DUK_USE_REGEXP_SUPPORT */
 #line 1 "duk_util_memrw.c"
 /*
  *  Macro support functions for reading/writing raw data.
@@ -13374,23 +14084,17 @@
  */
 
 DUK_INTERNAL const duk_uint8_t duk_lc_digits[36] = {
-	DUK_ASC_0, DUK_ASC_1, DUK_ASC_2, DUK_ASC_3,
-	DUK_ASC_4, DUK_ASC_5, DUK_ASC_6, DUK_ASC_7,
-	DUK_ASC_8, DUK_ASC_9, DUK_ASC_LC_A, DUK_ASC_LC_B,
-	DUK_ASC_LC_C, DUK_ASC_LC_D, DUK_ASC_LC_E, DUK_ASC_LC_F,
-	DUK_ASC_LC_G, DUK_ASC_LC_H, DUK_ASC_LC_I, DUK_ASC_LC_J,
-	DUK_ASC_LC_K, DUK_ASC_LC_L, DUK_ASC_LC_M, DUK_ASC_LC_N,
-	DUK_ASC_LC_O, DUK_ASC_LC_P, DUK_ASC_LC_Q, DUK_ASC_LC_R,
-	DUK_ASC_LC_S, DUK_ASC_LC_T, DUK_ASC_LC_U, DUK_ASC_LC_V,
+	DUK_ASC_0,    DUK_ASC_1,    DUK_ASC_2,    DUK_ASC_3,    DUK_ASC_4,    DUK_ASC_5,    DUK_ASC_6,    DUK_ASC_7,
+	DUK_ASC_8,    DUK_ASC_9,    DUK_ASC_LC_A, DUK_ASC_LC_B, DUK_ASC_LC_C, DUK_ASC_LC_D, DUK_ASC_LC_E, DUK_ASC_LC_F,
+	DUK_ASC_LC_G, DUK_ASC_LC_H, DUK_ASC_LC_I, DUK_ASC_LC_J, DUK_ASC_LC_K, DUK_ASC_LC_L, DUK_ASC_LC_M, DUK_ASC_LC_N,
+	DUK_ASC_LC_O, DUK_ASC_LC_P, DUK_ASC_LC_Q, DUK_ASC_LC_R, DUK_ASC_LC_S, DUK_ASC_LC_T, DUK_ASC_LC_U, DUK_ASC_LC_V,
 	DUK_ASC_LC_W, DUK_ASC_LC_X, DUK_ASC_LC_Y, DUK_ASC_LC_Z
 };
 
-DUK_INTERNAL const duk_uint8_t duk_uc_nybbles[16] = {
-	DUK_ASC_0, DUK_ASC_1, DUK_ASC_2, DUK_ASC_3,
-	DUK_ASC_4, DUK_ASC_5, DUK_ASC_6, DUK_ASC_7,
-	DUK_ASC_8, DUK_ASC_9, DUK_ASC_UC_A, DUK_ASC_UC_B,
-	DUK_ASC_UC_C, DUK_ASC_UC_D, DUK_ASC_UC_E, DUK_ASC_UC_F
-};
+DUK_INTERNAL const duk_uint8_t duk_uc_nybbles[16] = { DUK_ASC_0,    DUK_ASC_1,    DUK_ASC_2,    DUK_ASC_3,
+	                                              DUK_ASC_4,    DUK_ASC_5,    DUK_ASC_6,    DUK_ASC_7,
+	                                              DUK_ASC_8,    DUK_ASC_9,    DUK_ASC_UC_A, DUK_ASC_UC_B,
+	                                              DUK_ASC_UC_C, DUK_ASC_UC_D, DUK_ASC_UC_E, DUK_ASC_UC_F };
 
 /*
  *  Table for hex decoding ASCII hex digits
@@ -13398,43 +14102,43 @@
 
 DUK_INTERNAL const duk_int8_t duk_hex_dectab[256] = {
 	/* -1 if invalid */
-	-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 */
+	-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 */
 };
 
 #if defined(DUK_USE_HEX_FASTPATH)
 /* Preshifted << 4.  Must use 16-bit entry to allow negative value signaling. */
 DUK_INTERNAL const duk_int16_t duk_hex_dectab_shift4[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 */
-	0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90,   -1,   -1,   -1,   -1,   -1,   -1,  /* 0x30-0x3f */
-	  -1, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,   -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, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0,   -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 */
+	-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 */
+	0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, -1, -1, -1, -1, -1, -1, /* 0x30-0x3f */
+	-1,   0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, -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,   0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, -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 */
 };
 #endif
 
@@ -13453,77 +14157,53 @@
  *           print('0x' + t.encode('hex') + 'U')
  *   print('big endian'); genhextab(False)
  *   print('little endian'); genhextab(True)
-*/
+ */
 DUK_INTERNAL const duk_uint16_t duk_hex_enctab[256] = {
 #if defined(DUK_USE_INTEGER_BE)
-	0x3030U, 0x3031U, 0x3032U, 0x3033U, 0x3034U, 0x3035U, 0x3036U, 0x3037U,
-	0x3038U, 0x3039U, 0x3061U, 0x3062U, 0x3063U, 0x3064U, 0x3065U, 0x3066U,
-	0x3130U, 0x3131U, 0x3132U, 0x3133U, 0x3134U, 0x3135U, 0x3136U, 0x3137U,
-	0x3138U, 0x3139U, 0x3161U, 0x3162U, 0x3163U, 0x3164U, 0x3165U, 0x3166U,
-	0x3230U, 0x3231U, 0x3232U, 0x3233U, 0x3234U, 0x3235U, 0x3236U, 0x3237U,
-	0x3238U, 0x3239U, 0x3261U, 0x3262U, 0x3263U, 0x3264U, 0x3265U, 0x3266U,
-	0x3330U, 0x3331U, 0x3332U, 0x3333U, 0x3334U, 0x3335U, 0x3336U, 0x3337U,
-	0x3338U, 0x3339U, 0x3361U, 0x3362U, 0x3363U, 0x3364U, 0x3365U, 0x3366U,
-	0x3430U, 0x3431U, 0x3432U, 0x3433U, 0x3434U, 0x3435U, 0x3436U, 0x3437U,
-	0x3438U, 0x3439U, 0x3461U, 0x3462U, 0x3463U, 0x3464U, 0x3465U, 0x3466U,
-	0x3530U, 0x3531U, 0x3532U, 0x3533U, 0x3534U, 0x3535U, 0x3536U, 0x3537U,
-	0x3538U, 0x3539U, 0x3561U, 0x3562U, 0x3563U, 0x3564U, 0x3565U, 0x3566U,
-	0x3630U, 0x3631U, 0x3632U, 0x3633U, 0x3634U, 0x3635U, 0x3636U, 0x3637U,
-	0x3638U, 0x3639U, 0x3661U, 0x3662U, 0x3663U, 0x3664U, 0x3665U, 0x3666U,
-	0x3730U, 0x3731U, 0x3732U, 0x3733U, 0x3734U, 0x3735U, 0x3736U, 0x3737U,
-	0x3738U, 0x3739U, 0x3761U, 0x3762U, 0x3763U, 0x3764U, 0x3765U, 0x3766U,
-	0x3830U, 0x3831U, 0x3832U, 0x3833U, 0x3834U, 0x3835U, 0x3836U, 0x3837U,
-	0x3838U, 0x3839U, 0x3861U, 0x3862U, 0x3863U, 0x3864U, 0x3865U, 0x3866U,
-	0x3930U, 0x3931U, 0x3932U, 0x3933U, 0x3934U, 0x3935U, 0x3936U, 0x3937U,
-	0x3938U, 0x3939U, 0x3961U, 0x3962U, 0x3963U, 0x3964U, 0x3965U, 0x3966U,
-	0x6130U, 0x6131U, 0x6132U, 0x6133U, 0x6134U, 0x6135U, 0x6136U, 0x6137U,
-	0x6138U, 0x6139U, 0x6161U, 0x6162U, 0x6163U, 0x6164U, 0x6165U, 0x6166U,
-	0x6230U, 0x6231U, 0x6232U, 0x6233U, 0x6234U, 0x6235U, 0x6236U, 0x6237U,
-	0x6238U, 0x6239U, 0x6261U, 0x6262U, 0x6263U, 0x6264U, 0x6265U, 0x6266U,
-	0x6330U, 0x6331U, 0x6332U, 0x6333U, 0x6334U, 0x6335U, 0x6336U, 0x6337U,
-	0x6338U, 0x6339U, 0x6361U, 0x6362U, 0x6363U, 0x6364U, 0x6365U, 0x6366U,
-	0x6430U, 0x6431U, 0x6432U, 0x6433U, 0x6434U, 0x6435U, 0x6436U, 0x6437U,
-	0x6438U, 0x6439U, 0x6461U, 0x6462U, 0x6463U, 0x6464U, 0x6465U, 0x6466U,
-	0x6530U, 0x6531U, 0x6532U, 0x6533U, 0x6534U, 0x6535U, 0x6536U, 0x6537U,
-	0x6538U, 0x6539U, 0x6561U, 0x6562U, 0x6563U, 0x6564U, 0x6565U, 0x6566U,
-	0x6630U, 0x6631U, 0x6632U, 0x6633U, 0x6634U, 0x6635U, 0x6636U, 0x6637U,
-	0x6638U, 0x6639U, 0x6661U, 0x6662U, 0x6663U, 0x6664U, 0x6665U, 0x6666U
-#else  /* DUK_USE_INTEGER_BE */
-	0x3030U, 0x3130U, 0x3230U, 0x3330U, 0x3430U, 0x3530U, 0x3630U, 0x3730U,
-	0x3830U, 0x3930U, 0x6130U, 0x6230U, 0x6330U, 0x6430U, 0x6530U, 0x6630U,
-	0x3031U, 0x3131U, 0x3231U, 0x3331U, 0x3431U, 0x3531U, 0x3631U, 0x3731U,
-	0x3831U, 0x3931U, 0x6131U, 0x6231U, 0x6331U, 0x6431U, 0x6531U, 0x6631U,
-	0x3032U, 0x3132U, 0x3232U, 0x3332U, 0x3432U, 0x3532U, 0x3632U, 0x3732U,
-	0x3832U, 0x3932U, 0x6132U, 0x6232U, 0x6332U, 0x6432U, 0x6532U, 0x6632U,
-	0x3033U, 0x3133U, 0x3233U, 0x3333U, 0x3433U, 0x3533U, 0x3633U, 0x3733U,
-	0x3833U, 0x3933U, 0x6133U, 0x6233U, 0x6333U, 0x6433U, 0x6533U, 0x6633U,
-	0x3034U, 0x3134U, 0x3234U, 0x3334U, 0x3434U, 0x3534U, 0x3634U, 0x3734U,
-	0x3834U, 0x3934U, 0x6134U, 0x6234U, 0x6334U, 0x6434U, 0x6534U, 0x6634U,
-	0x3035U, 0x3135U, 0x3235U, 0x3335U, 0x3435U, 0x3535U, 0x3635U, 0x3735U,
-	0x3835U, 0x3935U, 0x6135U, 0x6235U, 0x6335U, 0x6435U, 0x6535U, 0x6635U,
-	0x3036U, 0x3136U, 0x3236U, 0x3336U, 0x3436U, 0x3536U, 0x3636U, 0x3736U,
-	0x3836U, 0x3936U, 0x6136U, 0x6236U, 0x6336U, 0x6436U, 0x6536U, 0x6636U,
-	0x3037U, 0x3137U, 0x3237U, 0x3337U, 0x3437U, 0x3537U, 0x3637U, 0x3737U,
-	0x3837U, 0x3937U, 0x6137U, 0x6237U, 0x6337U, 0x6437U, 0x6537U, 0x6637U,
-	0x3038U, 0x3138U, 0x3238U, 0x3338U, 0x3438U, 0x3538U, 0x3638U, 0x3738U,
-	0x3838U, 0x3938U, 0x6138U, 0x6238U, 0x6338U, 0x6438U, 0x6538U, 0x6638U,
-	0x3039U, 0x3139U, 0x3239U, 0x3339U, 0x3439U, 0x3539U, 0x3639U, 0x3739U,
-	0x3839U, 0x3939U, 0x6139U, 0x6239U, 0x6339U, 0x6439U, 0x6539U, 0x6639U,
-	0x3061U, 0x3161U, 0x3261U, 0x3361U, 0x3461U, 0x3561U, 0x3661U, 0x3761U,
-	0x3861U, 0x3961U, 0x6161U, 0x6261U, 0x6361U, 0x6461U, 0x6561U, 0x6661U,
-	0x3062U, 0x3162U, 0x3262U, 0x3362U, 0x3462U, 0x3562U, 0x3662U, 0x3762U,
-	0x3862U, 0x3962U, 0x6162U, 0x6262U, 0x6362U, 0x6462U, 0x6562U, 0x6662U,
-	0x3063U, 0x3163U, 0x3263U, 0x3363U, 0x3463U, 0x3563U, 0x3663U, 0x3763U,
-	0x3863U, 0x3963U, 0x6163U, 0x6263U, 0x6363U, 0x6463U, 0x6563U, 0x6663U,
-	0x3064U, 0x3164U, 0x3264U, 0x3364U, 0x3464U, 0x3564U, 0x3664U, 0x3764U,
-	0x3864U, 0x3964U, 0x6164U, 0x6264U, 0x6364U, 0x6464U, 0x6564U, 0x6664U,
-	0x3065U, 0x3165U, 0x3265U, 0x3365U, 0x3465U, 0x3565U, 0x3665U, 0x3765U,
-	0x3865U, 0x3965U, 0x6165U, 0x6265U, 0x6365U, 0x6465U, 0x6565U, 0x6665U,
-	0x3066U, 0x3166U, 0x3266U, 0x3366U, 0x3466U, 0x3566U, 0x3666U, 0x3766U,
-	0x3866U, 0x3966U, 0x6166U, 0x6266U, 0x6366U, 0x6466U, 0x6566U, 0x6666U
-#endif  /* DUK_USE_INTEGER_BE */
+	0x3030U, 0x3031U, 0x3032U, 0x3033U, 0x3034U, 0x3035U, 0x3036U, 0x3037U, 0x3038U, 0x3039U, 0x3061U, 0x3062U, 0x3063U,
+	0x3064U, 0x3065U, 0x3066U, 0x3130U, 0x3131U, 0x3132U, 0x3133U, 0x3134U, 0x3135U, 0x3136U, 0x3137U, 0x3138U, 0x3139U,
+	0x3161U, 0x3162U, 0x3163U, 0x3164U, 0x3165U, 0x3166U, 0x3230U, 0x3231U, 0x3232U, 0x3233U, 0x3234U, 0x3235U, 0x3236U,
+	0x3237U, 0x3238U, 0x3239U, 0x3261U, 0x3262U, 0x3263U, 0x3264U, 0x3265U, 0x3266U, 0x3330U, 0x3331U, 0x3332U, 0x3333U,
+	0x3334U, 0x3335U, 0x3336U, 0x3337U, 0x3338U, 0x3339U, 0x3361U, 0x3362U, 0x3363U, 0x3364U, 0x3365U, 0x3366U, 0x3430U,
+	0x3431U, 0x3432U, 0x3433U, 0x3434U, 0x3435U, 0x3436U, 0x3437U, 0x3438U, 0x3439U, 0x3461U, 0x3462U, 0x3463U, 0x3464U,
+	0x3465U, 0x3466U, 0x3530U, 0x3531U, 0x3532U, 0x3533U, 0x3534U, 0x3535U, 0x3536U, 0x3537U, 0x3538U, 0x3539U, 0x3561U,
+	0x3562U, 0x3563U, 0x3564U, 0x3565U, 0x3566U, 0x3630U, 0x3631U, 0x3632U, 0x3633U, 0x3634U, 0x3635U, 0x3636U, 0x3637U,
+	0x3638U, 0x3639U, 0x3661U, 0x3662U, 0x3663U, 0x3664U, 0x3665U, 0x3666U, 0x3730U, 0x3731U, 0x3732U, 0x3733U, 0x3734U,
+	0x3735U, 0x3736U, 0x3737U, 0x3738U, 0x3739U, 0x3761U, 0x3762U, 0x3763U, 0x3764U, 0x3765U, 0x3766U, 0x3830U, 0x3831U,
+	0x3832U, 0x3833U, 0x3834U, 0x3835U, 0x3836U, 0x3837U, 0x3838U, 0x3839U, 0x3861U, 0x3862U, 0x3863U, 0x3864U, 0x3865U,
+	0x3866U, 0x3930U, 0x3931U, 0x3932U, 0x3933U, 0x3934U, 0x3935U, 0x3936U, 0x3937U, 0x3938U, 0x3939U, 0x3961U, 0x3962U,
+	0x3963U, 0x3964U, 0x3965U, 0x3966U, 0x6130U, 0x6131U, 0x6132U, 0x6133U, 0x6134U, 0x6135U, 0x6136U, 0x6137U, 0x6138U,
+	0x6139U, 0x6161U, 0x6162U, 0x6163U, 0x6164U, 0x6165U, 0x6166U, 0x6230U, 0x6231U, 0x6232U, 0x6233U, 0x6234U, 0x6235U,
+	0x6236U, 0x6237U, 0x6238U, 0x6239U, 0x6261U, 0x6262U, 0x6263U, 0x6264U, 0x6265U, 0x6266U, 0x6330U, 0x6331U, 0x6332U,
+	0x6333U, 0x6334U, 0x6335U, 0x6336U, 0x6337U, 0x6338U, 0x6339U, 0x6361U, 0x6362U, 0x6363U, 0x6364U, 0x6365U, 0x6366U,
+	0x6430U, 0x6431U, 0x6432U, 0x6433U, 0x6434U, 0x6435U, 0x6436U, 0x6437U, 0x6438U, 0x6439U, 0x6461U, 0x6462U, 0x6463U,
+	0x6464U, 0x6465U, 0x6466U, 0x6530U, 0x6531U, 0x6532U, 0x6533U, 0x6534U, 0x6535U, 0x6536U, 0x6537U, 0x6538U, 0x6539U,
+	0x6561U, 0x6562U, 0x6563U, 0x6564U, 0x6565U, 0x6566U, 0x6630U, 0x6631U, 0x6632U, 0x6633U, 0x6634U, 0x6635U, 0x6636U,
+	0x6637U, 0x6638U, 0x6639U, 0x6661U, 0x6662U, 0x6663U, 0x6664U, 0x6665U, 0x6666U
+#else /* DUK_USE_INTEGER_BE */
+	0x3030U, 0x3130U, 0x3230U, 0x3330U, 0x3430U, 0x3530U, 0x3630U, 0x3730U, 0x3830U, 0x3930U, 0x6130U, 0x6230U, 0x6330U,
+	0x6430U, 0x6530U, 0x6630U, 0x3031U, 0x3131U, 0x3231U, 0x3331U, 0x3431U, 0x3531U, 0x3631U, 0x3731U, 0x3831U, 0x3931U,
+	0x6131U, 0x6231U, 0x6331U, 0x6431U, 0x6531U, 0x6631U, 0x3032U, 0x3132U, 0x3232U, 0x3332U, 0x3432U, 0x3532U, 0x3632U,
+	0x3732U, 0x3832U, 0x3932U, 0x6132U, 0x6232U, 0x6332U, 0x6432U, 0x6532U, 0x6632U, 0x3033U, 0x3133U, 0x3233U, 0x3333U,
+	0x3433U, 0x3533U, 0x3633U, 0x3733U, 0x3833U, 0x3933U, 0x6133U, 0x6233U, 0x6333U, 0x6433U, 0x6533U, 0x6633U, 0x3034U,
+	0x3134U, 0x3234U, 0x3334U, 0x3434U, 0x3534U, 0x3634U, 0x3734U, 0x3834U, 0x3934U, 0x6134U, 0x6234U, 0x6334U, 0x6434U,
+	0x6534U, 0x6634U, 0x3035U, 0x3135U, 0x3235U, 0x3335U, 0x3435U, 0x3535U, 0x3635U, 0x3735U, 0x3835U, 0x3935U, 0x6135U,
+	0x6235U, 0x6335U, 0x6435U, 0x6535U, 0x6635U, 0x3036U, 0x3136U, 0x3236U, 0x3336U, 0x3436U, 0x3536U, 0x3636U, 0x3736U,
+	0x3836U, 0x3936U, 0x6136U, 0x6236U, 0x6336U, 0x6436U, 0x6536U, 0x6636U, 0x3037U, 0x3137U, 0x3237U, 0x3337U, 0x3437U,
+	0x3537U, 0x3637U, 0x3737U, 0x3837U, 0x3937U, 0x6137U, 0x6237U, 0x6337U, 0x6437U, 0x6537U, 0x6637U, 0x3038U, 0x3138U,
+	0x3238U, 0x3338U, 0x3438U, 0x3538U, 0x3638U, 0x3738U, 0x3838U, 0x3938U, 0x6138U, 0x6238U, 0x6338U, 0x6438U, 0x6538U,
+	0x6638U, 0x3039U, 0x3139U, 0x3239U, 0x3339U, 0x3439U, 0x3539U, 0x3639U, 0x3739U, 0x3839U, 0x3939U, 0x6139U, 0x6239U,
+	0x6339U, 0x6439U, 0x6539U, 0x6639U, 0x3061U, 0x3161U, 0x3261U, 0x3361U, 0x3461U, 0x3561U, 0x3661U, 0x3761U, 0x3861U,
+	0x3961U, 0x6161U, 0x6261U, 0x6361U, 0x6461U, 0x6561U, 0x6661U, 0x3062U, 0x3162U, 0x3262U, 0x3362U, 0x3462U, 0x3562U,
+	0x3662U, 0x3762U, 0x3862U, 0x3962U, 0x6162U, 0x6262U, 0x6362U, 0x6462U, 0x6562U, 0x6662U, 0x3063U, 0x3163U, 0x3263U,
+	0x3363U, 0x3463U, 0x3563U, 0x3663U, 0x3763U, 0x3863U, 0x3963U, 0x6163U, 0x6263U, 0x6363U, 0x6463U, 0x6563U, 0x6663U,
+	0x3064U, 0x3164U, 0x3264U, 0x3364U, 0x3464U, 0x3564U, 0x3664U, 0x3764U, 0x3864U, 0x3964U, 0x6164U, 0x6264U, 0x6364U,
+	0x6464U, 0x6564U, 0x6664U, 0x3065U, 0x3165U, 0x3265U, 0x3365U, 0x3465U, 0x3565U, 0x3665U, 0x3765U, 0x3865U, 0x3965U,
+	0x6165U, 0x6265U, 0x6365U, 0x6465U, 0x6565U, 0x6665U, 0x3066U, 0x3166U, 0x3266U, 0x3366U, 0x3466U, 0x3566U, 0x3666U,
+	0x3766U, 0x3866U, 0x3966U, 0x6166U, 0x6266U, 0x6366U, 0x6466U, 0x6566U, 0x6666U
+#endif /* DUK_USE_INTEGER_BE */
 };
-#endif  /* DUK_USE_HEX_FASTPATH */
+#endif /* DUK_USE_HEX_FASTPATH */
 
 /*
  *  Arbitrary byteswap for potentially unaligned values
@@ -13531,7 +14211,7 @@
  *  Used to byteswap pointers e.g. in debugger code.
  */
 
-#if defined(DUK_USE_DEBUGGER_SUPPORT)  /* For now only needed by the debugger. */
+#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;
@@ -13545,6 +14225,18 @@
 	}
 }
 #endif
+
+/*
+ *  Random
+ */
+
+DUK_INTERNAL duk_double_t duk_util_get_random_double(duk_hthread *thr) {
+#if defined(DUK_USE_GET_RANDOM_DOUBLE)
+	return DUK_USE_GET_RANDOM_DOUBLE(thr->heap->heap_udata);
+#else
+	return duk_util_tinyrandom_get_double(thr);
+#endif
+}
 #line 1 "duk_hobject_class.c"
 /*
  *  Hobject ECMAScript [[Class]].
@@ -13642,7 +14334,7 @@
 
 /* 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,  /* NONE, intentionally empty */
+	DUK_STRIDX_EMPTY_STRING, /* NONE, intentionally empty */
 	DUK_STRIDX_UC_OBJECT,
 	DUK_STRIDX_UC_ARRAY,
 	DUK_STRIDX_UC_FUNCTION,
@@ -13672,8 +14364,8 @@
 	DUK_STRIDX_UINT32_ARRAY,
 	DUK_STRIDX_FLOAT32_ARRAY,
 	DUK_STRIDX_FLOAT64_ARRAY,
-	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"
 /*
@@ -13690,8 +14382,7 @@
 	void *res;
 	DUK_UNREF(udata);
 	res = DUK_ANSI_MALLOC(size);
-	DUK_DDD(DUK_DDDPRINT("default alloc function: %lu -> %p",
-	                     (unsigned long) size, (void *) res));
+	DUK_DDD(DUK_DDDPRINT("default alloc function: %lu -> %p", (unsigned long) size, (void *) res));
 	return res;
 }
 
@@ -13699,8 +14390,7 @@
 	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));
+	DUK_DDD(DUK_DDDPRINT("default realloc function: %p %lu -> %p", (void *) ptr, (unsigned long) newsize, (void *) res));
 	return res;
 }
 
@@ -13709,7 +14399,7 @@
 	DUK_UNREF(udata);
 	DUK_ANSI_FREE(ptr);
 }
-#endif  /* DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS */
+#endif /* DUK_USE_PROVIDE_DEFAULT_ALLOC_FUNCTIONS */
 #line 1 "duk_api_buffer.c"
 /*
  *  Buffer
@@ -13801,11 +14491,11 @@
 
 #if defined(DUK_USE_BYTECODE_DUMP_SUPPORT)
 
-#define DUK__SER_MARKER  0xbf
-#define DUK__SER_STRING  0x00
-#define DUK__SER_NUMBER  0x01
+#define DUK__SER_MARKER             0xbf
+#define DUK__SER_STRING             0x00
+#define DUK__SER_NUMBER             0x01
 #define DUK__BYTECODE_INITIAL_ALLOC 256
-#define DUK__NO_FORMALS  0xffffffffUL
+#define DUK__NO_FORMALS             0xffffffffUL
 
 /*
  *  Dump/load helpers, xxx_raw() helpers do no buffer checks
@@ -13839,12 +14529,10 @@
 	DUK_ASSERT(h != NULL);
 
 	len = DUK_HSTRING_GET_BYTELEN(h);
-	DUK_ASSERT(len <= 0xffffffffUL);  /* string limits */
+	DUK_ASSERT(len <= 0xffffffffUL); /* string limits */
 	tmp32 = (duk_uint32_t) len;
 	DUK_RAW_WRITEINC_U32_BE(p, tmp32);
-	duk_memcpy((void *) p,
-	           (const void *) DUK_HSTRING_GET_DATA(h),
-	           len);
+	duk_memcpy((void *) p, (const void *) DUK_HSTRING_GET_DATA(h), len);
 	p += len;
 	return p;
 }
@@ -13858,18 +14546,20 @@
 	DUK_UNREF(thr);
 
 	len = DUK_HBUFFER_GET_SIZE(h);
-	DUK_ASSERT(len <= 0xffffffffUL);  /* buffer limits */
+	DUK_ASSERT(len <= 0xffffffffUL); /* buffer limits */
 	tmp32 = (duk_uint32_t) len;
 	DUK_RAW_WRITEINC_U32_BE(p, tmp32);
 	/* When len == 0, buffer data pointer may be NULL. */
-	duk_memcpy_unsafe((void *) p,
-	                  (const void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h),
-	                  len);
+	duk_memcpy_unsafe((void *) p, (const void *) DUK_HBUFFER_GET_DATA_PTR(thr->heap, h), len);
 	p += len;
 	return p;
 }
 
-DUK_LOCAL duk_uint8_t *duk__dump_string_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx) {
+DUK_LOCAL duk_uint8_t *duk__dump_string_prop(duk_hthread *thr,
+                                             duk_uint8_t *p,
+                                             duk_bufwriter_ctx *bw_ctx,
+                                             duk_hobject *func,
+                                             duk_small_uint_t stridx) {
 	duk_hstring *h_str;
 	duk_tval *tv;
 
@@ -13881,13 +14571,17 @@
 		h_str = DUK_HTHREAD_STRING_EMPTY_STRING(thr);
 		DUK_ASSERT(h_str != NULL);
 	}
-	DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL);  /* ensures no overflow */
+	DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */
 	p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4U + DUK_HSTRING_GET_BYTELEN(h_str), p);
 	p = duk__dump_hstring_raw(p, h_str);
 	return p;
 }
 
-DUK_LOCAL duk_uint8_t *duk__dump_buffer_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx) {
+DUK_LOCAL duk_uint8_t *duk__dump_buffer_prop(duk_hthread *thr,
+                                             duk_uint8_t *p,
+                                             duk_bufwriter_ctx *bw_ctx,
+                                             duk_hobject *func,
+                                             duk_small_uint_t stridx) {
 	duk_tval *tv;
 
 	tv = duk_hobject_find_entry_tval_ptr_stridx(thr->heap, (duk_hobject *) func, stridx);
@@ -13895,7 +14589,7 @@
 		duk_hbuffer *h_buf;
 		h_buf = DUK_TVAL_GET_BUFFER(tv);
 		DUK_ASSERT(h_buf != NULL);
-		DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7fffffffUL);  /* ensures no overflow */
+		DUK_ASSERT(DUK_HBUFFER_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */
 		p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4U + DUK_HBUFFER_GET_SIZE(h_buf), p);
 		p = duk__dump_hbuffer_raw(thr, p, h_buf);
 	} else {
@@ -13905,7 +14599,12 @@
 	return p;
 }
 
-DUK_LOCAL duk_uint8_t *duk__dump_uint32_prop(duk_hthread *thr, duk_uint8_t *p, duk_bufwriter_ctx *bw_ctx, duk_hobject *func, duk_small_uint_t stridx, duk_uint32_t def_value) {
+DUK_LOCAL duk_uint8_t *duk__dump_uint32_prop(duk_hthread *thr,
+                                             duk_uint8_t *p,
+                                             duk_bufwriter_ctx *bw_ctx,
+                                             duk_hobject *func,
+                                             duk_small_uint_t stridx,
+                                             duk_uint32_t def_value) {
 	duk_tval *tv;
 	duk_uint32_t val;
 
@@ -13938,27 +14637,28 @@
 			duk_uint32_t val;
 
 			key = DUK_HOBJECT_E_GET_KEY(thr->heap, h, i);
-			DUK_ASSERT(key != NULL);  /* _Varmap is dense */
+			DUK_ASSERT(key != NULL); /* _Varmap is dense */
 			DUK_ASSERT(!DUK_HOBJECT_E_SLOT_IS_ACCESSOR(thr->heap, h, i));
 			tv_val = DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(thr->heap, h, i);
 			DUK_ASSERT(tv_val != NULL);
-			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_val));  /* known to be number; in fact an integer */
+			DUK_ASSERT(DUK_TVAL_IS_NUMBER(tv_val)); /* known to be number; in fact an integer */
 #if defined(DUK_USE_FASTINT)
 			DUK_ASSERT(DUK_TVAL_IS_FASTINT(tv_val));
-			DUK_ASSERT(DUK_TVAL_GET_FASTINT(tv_val) == (duk_int64_t) DUK_TVAL_GET_FASTINT_U32(tv_val));  /* known to be 32-bit */
+			DUK_ASSERT(DUK_TVAL_GET_FASTINT(tv_val) ==
+			           (duk_int64_t) DUK_TVAL_GET_FASTINT_U32(tv_val)); /* known to be 32-bit */
 			val = DUK_TVAL_GET_FASTINT_U32(tv_val);
 #else
 			val = (duk_uint32_t) DUK_TVAL_GET_NUMBER(tv_val);
 #endif
 
-			DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL);  /* ensures no overflow */
+			DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */
 			p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4U + DUK_HSTRING_GET_BYTELEN(key) + 4U, p);
 			p = duk__dump_hstring_raw(p, key);
 			DUK_RAW_WRITEINC_U32_BE(p, val);
 		}
 	}
 	p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4U, p);
-	DUK_RAW_WRITEINC_U32_BE(p, 0);  /* end of _Varmap */
+	DUK_RAW_WRITEINC_U32_BE(p, 0); /* end of _Varmap */
 	return p;
 }
 
@@ -13976,7 +14676,7 @@
 		 */
 
 		p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4U, p);
-		DUK_ASSERT(h->length != DUK__NO_FORMALS);  /* limits */
+		DUK_ASSERT(h->length != DUK__NO_FORMALS); /* limits */
 		DUK_RAW_WRITEINC_U32_BE(p, h->length);
 
 		for (i = 0; i < h->length; i++) {
@@ -13991,14 +14691,14 @@
 			DUK_ASSERT(varname != NULL);
 			DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(varname) >= 1);
 
-			DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL);  /* ensures no overflow */
+			DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */
 			p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4U + DUK_HSTRING_GET_BYTELEN(varname), p);
 			p = duk__dump_hstring_raw(p, varname);
 		}
 	} else {
 		DUK_DD(DUK_DDPRINT("dumping function without _Formals, emit marker to indicate missing _Formals"));
 		p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 4U, p);
-		DUK_RAW_WRITEINC_U32_BE(p, DUK__NO_FORMALS);  /* marker: no formals */
+		DUK_RAW_WRITEINC_U32_BE(p, DUK__NO_FORMALS); /* marker: no formals */
 	}
 	return p;
 }
@@ -14032,7 +14732,7 @@
 	                   (long) DUK_HCOMPFUNC_GET_CODE_SIZE(thr->heap, func),
 	                   (long) DUK_HCOMPFUNC_GET_CODE_COUNT(thr->heap, func)));
 
-	DUK_ASSERT(DUK_USE_ESBC_MAX_BYTES <= 0x7fffffffUL);  /* ensures no overflow */
+	DUK_ASSERT(DUK_USE_ESBC_MAX_BYTES <= 0x7fffffffUL); /* ensures no overflow */
 	count_instr = (duk_uint32_t) DUK_HCOMPFUNC_GET_CODE_COUNT(thr->heap, func);
 	p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 3U * 4U + 2U * 2U + 3U * 4U + count_instr * 4U, p);
 
@@ -14056,8 +14756,8 @@
 	DUK_RAW_WRITEINC_U32_BE(p, 0);
 	DUK_RAW_WRITEINC_U32_BE(p, 0);
 #endif
-	tmp32 = DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) func);  /* masks flags, only duk_hobject flags */
-	tmp32 &= ~(DUK_HOBJECT_FLAG_HAVE_FINALIZER);  /* finalizer flag is lost */
+	tmp32 = DUK_HEAPHDR_GET_FLAGS((duk_heaphdr *) func); /* masks flags, only duk_hobject flags */
+	tmp32 &= ~(DUK_HOBJECT_FLAG_HAVE_FINALIZER); /* finalizer flag is lost */
 	DUK_RAW_WRITEINC_U32_BE(p, tmp32);
 
 	/* Bytecode instructions: endian conversion needed unless
@@ -14067,8 +14767,9 @@
 	ins_end = DUK_HCOMPFUNC_GET_CODE_END(thr->heap, func);
 	DUK_ASSERT((duk_size_t) (ins_end - ins) == (duk_size_t) count_instr);
 #if defined(DUK_USE_INTEGER_BE)
-	duk_memcpy_unsafe((void *) p, (const void *) ins, (size_t) (ins_end - ins));
-	p += (size_t) (ins_end - ins);
+	duk_memcpy_unsafe((void *) p, (const void *) ins, count_instr * sizeof(duk_instr_t));
+	p += count_instr * sizeof(duk_instr_t);
+	DUK_UNREF(ins_end);
 #else
 	while (ins != ins_end) {
 		tmp32 = (duk_uint32_t) (*ins);
@@ -14082,13 +14783,12 @@
 	tv_end = DUK_HCOMPFUNC_GET_CONSTS_END(thr->heap, func);
 	while (tv != tv_end) {
 		/* constants are strings or numbers now */
-		DUK_ASSERT(DUK_TVAL_IS_STRING(tv) ||
-		           DUK_TVAL_IS_NUMBER(tv));
+		DUK_ASSERT(DUK_TVAL_IS_STRING(tv) || DUK_TVAL_IS_NUMBER(tv));
 
 		if (DUK_TVAL_IS_STRING(tv)) {
 			h_str = DUK_TVAL_GET_STRING(tv);
 			DUK_ASSERT(h_str != NULL);
-			DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL);  /* ensures no overflow */
+			DUK_ASSERT(DUK_HSTRING_MAX_BYTELEN <= 0x7fffffffUL); /* ensures no overflow */
 			p = DUK_BW_ENSURE_RAW(thr, bw_ctx, 1U + 4U + DUK_HSTRING_GET_BYTELEN(h_str), p);
 			*p++ = DUK__SER_STRING;
 			p = duk__dump_hstring_raw(p, h_str);
@@ -14154,7 +14854,8 @@
  * are validated (which is quite complex, especially for indirect opcodes).
  */
 
-#define DUK__ASSERT_LEFT(n) do { \
+#define DUK__ASSERT_LEFT(n) \
+	do { \
 		DUK_ASSERT((duk_size_t) (p_end - p) >= (duk_size_t) (n)); \
 	} while (0)
 
@@ -14189,13 +14890,13 @@
 	count_const = DUK_RAW_READINC_U32_BE(p);
 	count_funcs = DUK_RAW_READINC_U32_BE(p);
 
-	data_size = sizeof(duk_tval) * count_const +
-	            sizeof(duk_hobject *) * count_funcs +
-	            sizeof(duk_instr_t) * count_instr;
+	data_size = sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs + sizeof(duk_instr_t) * count_instr;
 
 	DUK_DD(DUK_DDPRINT("instr=%ld, const=%ld, funcs=%ld, data_size=%ld",
-	                   (long) count_instr, (long) count_const,
-	                   (long) count_const, (long) data_size));
+	                   (long) count_instr,
+	                   (long) count_const,
+	                   (long) count_const,
+	                   (long) data_size));
 
 	/* Value stack is used to ensure reachability of constants and
 	 * inner functions being loaded.  Require enough space to handle
@@ -14221,12 +14922,12 @@
 	h_fun->start_line = DUK_RAW_READINC_U32_BE(p);
 	h_fun->end_line = DUK_RAW_READINC_U32_BE(p);
 #else
-	p += 8;  /* skip line info */
+	p += 8; /* skip line info */
 #endif
 
 	/* duk_hcompfunc flags; quite version specific */
 	tmp32 = DUK_RAW_READINC_U32_BE(p);
-	DUK_HEAPHDR_SET_FLAGS((duk_heaphdr *) h_fun, tmp32);  /* masks flags to only change duk_hobject flags */
+	DUK_HEAPHDR_SET_FLAGS((duk_heaphdr *) h_fun, tmp32); /* masks flags to only change duk_hobject flags */
 
 	/* standard prototype (no need to set here, already set) */
 	DUK_ASSERT(DUK_HOBJECT_GET_PROTOTYPE(thr->heap, (duk_hobject *) h_fun) == thr->builtins[DUK_BIDX_FUNCTION_PROTOTYPE]);
@@ -14254,9 +14955,7 @@
 	DUK__ASSERT_LEFT(count_instr * sizeof(duk_instr_t));
 #if defined(DUK_USE_INTEGER_BE)
 	q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs;
-	duk_memcpy((void *) q,
-	           (const void *) p,
-	           sizeof(duk_instr_t) * count_instr);
+	duk_memcpy((void *) q, (const void *) p, sizeof(duk_instr_t) * count_instr);
 	p += sizeof(duk_instr_t) * count_instr;
 #else
 	q = fun_data + sizeof(duk_tval) * count_const + sizeof(duk_hobject *) * count_funcs;
@@ -14315,13 +15014,13 @@
 	DUK_HCOMPFUNC_SET_DATA(thr->heap, h_fun, h_data);
 	DUK_HBUFFER_INCREF(thr, h_data);
 
-	tv1 = duk_get_tval(thr, idx_base + 2);  /* may be NULL if no constants or inner funcs */
+	tv1 = duk_get_tval(thr, idx_base + 2); /* may be NULL if no constants or inner funcs */
 	DUK_ASSERT((count_const == 0 && count_funcs == 0) || tv1 != NULL);
 
 	q = fun_data;
 	duk_memcpy_unsafe((void *) q, (const void *) tv1, sizeof(duk_tval) * count_const);
 	for (n = count_const; n > 0; n--) {
-		DUK_TVAL_INCREF_FAST(thr, (duk_tval *) (void *) q);  /* no side effects */
+		DUK_TVAL_INCREF_FAST(thr, (duk_tval *) (void *) q); /* no side effects */
 		q += sizeof(duk_tval);
 	}
 	tv1 += count_const;
@@ -14354,7 +15053,7 @@
 	duk_xdef_prop_stridx_short(thr, -2, DUK_STRIDX_LENGTH, DUK_PROPDESC_FLAGS_C);
 
 #if defined(DUK_USE_FUNC_NAME_PROPERTY)
-	p = duk__load_string_raw(thr, p);  /* -> [ func funcname ] */
+	p = duk__load_string_raw(thr, p); /* -> [ func funcname ] */
 	func_env = thr->builtins[DUK_BIDX_GLOBAL_ENV];
 	DUK_ASSERT(func_env != NULL);
 	need_pop = 0;
@@ -14365,11 +15064,10 @@
 		 */
 		duk_hdecenv *new_env;
 
-		new_env = duk_hdecenv_alloc(thr,
-		                            DUK_HOBJECT_FLAG_EXTENSIBLE |
-		                            DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV));
+		new_env =
+		    duk_hdecenv_alloc(thr, DUK_HOBJECT_FLAG_EXTENSIBLE | DUK_HOBJECT_CLASS_AS_FLAGS(DUK_HOBJECT_CLASS_DECENV));
 		DUK_ASSERT(new_env != NULL);
-		DUK_ASSERT(new_env->thread == NULL);  /* Closed. */
+		DUK_ASSERT(new_env->thread == NULL); /* Closed. */
 		DUK_ASSERT(new_env->varmap == NULL);
 		DUK_ASSERT(new_env->regbase_byteoff == 0);
 		DUK_HDECENV_ASSERT_VALID(new_env);
@@ -14381,11 +15079,11 @@
 
 		duk_push_hobject(thr, (duk_hobject *) new_env);
 
-		duk_dup_m2(thr);                                  /* -> [ func funcname env funcname ] */
-		duk_dup(thr, idx_base);                           /* -> [ func funcname env funcname func ] */
-		duk_xdef_prop(thr, -3, DUK_PROPDESC_FLAGS_NONE);  /* -> [ func funcname env ] */
+		duk_dup_m2(thr); /* -> [ func funcname env funcname ] */
+		duk_dup(thr, idx_base); /* -> [ func funcname env funcname func ] */
+		duk_xdef_prop(thr, -3, DUK_PROPDESC_FLAGS_NONE); /* -> [ func funcname env ] */
 
-		need_pop = 1;  /* Need to pop env, but -after- updating h_fun and increfs. */
+		need_pop = 1; /* Need to pop env, but -after- updating h_fun and increfs. */
 	}
 	DUK_ASSERT(func_env != NULL);
 	DUK_HCOMPFUNC_SET_LEXENV(thr->heap, h_fun, func_env);
@@ -14396,12 +15094,12 @@
 		duk_pop(thr);
 	}
 	duk_xdef_prop_stridx_short(thr, -2, DUK_STRIDX_NAME, DUK_PROPDESC_FLAGS_C);
-#endif  /* DUK_USE_FUNC_NAME_PROPERTY */
+#endif /* DUK_USE_FUNC_NAME_PROPERTY */
 
 #if defined(DUK_USE_FUNC_FILENAME_PROPERTY)
 	p = duk__load_string_raw(thr, p);
 	duk_xdef_prop_stridx_short(thr, -2, DUK_STRIDX_FILE_NAME, DUK_PROPDESC_FLAGS_C);
-#endif  /* DUK_USE_FUNC_FILENAME_PROPERTY */
+#endif /* DUK_USE_FUNC_FILENAME_PROPERTY */
 
 	if (DUK_HOBJECT_HAS_CONSTRUCTABLE((duk_hobject *) h_fun)) {
 		/* Restore empty external .prototype only for constructable
@@ -14411,7 +15109,10 @@
 		duk_push_object(thr);
 		DUK_ASSERT(!duk_is_bare_object(thr, -1));
 		duk_dup_m2(thr);
-		duk_xdef_prop_stridx_short(thr, -2, DUK_STRIDX_CONSTRUCTOR, DUK_PROPDESC_FLAGS_WC);  /* func.prototype.constructor = func */
+		duk_xdef_prop_stridx_short(thr,
+		                           -2,
+		                           DUK_STRIDX_CONSTRUCTOR,
+		                           DUK_PROPDESC_FLAGS_WC); /* func.prototype.constructor = func */
 		duk_compact_m1(thr);
 		duk_xdef_prop_stridx_short(thr, -2, DUK_STRIDX_PROTOTYPE, DUK_PROPDESC_FLAGS_W);
 	}
@@ -14419,9 +15120,9 @@
 #if defined(DUK_USE_PC2LINE)
 	p = duk__load_buffer_raw(thr, p);
 	duk_xdef_prop_stridx_short(thr, -2, DUK_STRIDX_INT_PC2LINE, DUK_PROPDESC_FLAGS_WC);
-#endif  /* DUK_USE_PC2LINE */
+#endif /* DUK_USE_PC2LINE */
 
-	duk_push_bare_object(thr);  /* _Varmap */
+	duk_push_bare_object(thr); /* _Varmap */
 	for (;;) {
 		/* XXX: awkward */
 		p = duk__load_string_raw(thr, p);
@@ -14441,7 +15142,7 @@
 	 */
 	arr_limit = DUK_RAW_READINC_U32_BE(p);
 	if (arr_limit != DUK__NO_FORMALS) {
-		duk_push_bare_array(thr);  /* _Formals */
+		duk_push_bare_array(thr); /* _Formals */
 		for (arr_idx = 0; arr_idx < arr_limit; arr_idx++) {
 			p = duk__load_string_raw(thr, p);
 			duk_put_prop_index(thr, -2, arr_idx);
@@ -14457,7 +15158,7 @@
 	DUK_ASSERT_TOP(thr, idx_base + 1);
 	return p;
 
- format_error:
+format_error:
 	return NULL;
 }
 
@@ -14489,7 +15190,7 @@
 
 	DUK_DD(DUK_DDPRINT("serialized result: %!T", duk_get_tval(thr, -1)));
 
-	duk_remove_m2(thr);  /* [ ... func buf ] -> [ ... buf ] */
+	duk_remove_m2(thr); /* [ ... func buf ] -> [ ... buf ] */
 }
 
 DUK_EXTERNAL void duk_load_function(duk_hthread *thr) {
@@ -14522,15 +15223,15 @@
 		goto format_error;
 	}
 
-	duk_remove_m2(thr);  /* [ ... buf func ] -> [ ... func ] */
+	duk_remove_m2(thr); /* [ ... buf func ] -> [ ... func ] */
 	return;
 
- format_error:
+format_error:
 	DUK_ERROR_TYPE(thr, DUK_STR_INVALID_BYTECODE);
 	DUK_WO_NORETURN(return;);
 }
 
-#else  /* DUK_USE_BYTECODE_DUMP_SUPPORT */
+#else /* DUK_USE_BYTECODE_DUMP_SUPPORT */
 
 DUK_EXTERNAL void duk_dump_function(duk_hthread *thr) {
 	DUK_ASSERT_API_ENTRY(thr);
@@ -14544,7 +15245,7 @@
 	DUK_WO_NORETURN(return;);
 }
 
-#endif  /* DUK_USE_BYTECODE_DUMP_SUPPORT */
+#endif /* DUK_USE_BYTECODE_DUMP_SUPPORT */
 
 /* automatic undefs */
 #undef DUK__ASSERT_LEFT
@@ -14607,7 +15308,7 @@
 	DUK_ASSERT(other >= 0);
 
 	idx_func = duk_get_top(thr) - nargs - other;
-	if (DUK_UNLIKELY((idx_func | nargs) < 0)) {  /* idx_func < 0 || nargs < 0; OR sign bits */
+	if (DUK_UNLIKELY((idx_func | nargs) < 0)) { /* idx_func < 0 || nargs < 0; OR sign bits */
 		DUK_ERROR_TYPE_INVALID_ARGS(thr);
 		DUK_WO_NORETURN(return 0;);
 	}
@@ -14641,12 +15342,14 @@
 	DUK_ASSERT(nargs >= 0);
 
 	DUK_DDD(DUK_DDDPRINT("duk__call_prop_prep_stack, normalized_obj_idx=%ld, nargs=%ld, stacktop=%ld",
-	                     (long) normalized_obj_idx, (long) nargs, (long) duk_get_top(thr)));
+	                     (long) normalized_obj_idx,
+	                     (long) nargs,
+	                     (long) duk_get_top(thr)));
 
 	/* [... key arg1 ... argN] */
 
 	/* duplicate key */
-	duk_dup(thr, -nargs - 1);  /* Note: -nargs alone would fail for nargs == 0, this is OK */
+	duk_dup(thr, -nargs - 1); /* Note: -nargs alone would fail for nargs == 0, this is OK */
 	(void) duk_get_prop(thr, normalized_obj_idx);
 
 	DUK_DDD(DUK_DDDPRINT("func: %!T", (duk_tval *) duk_get_tval(thr, -1)));
@@ -14689,7 +15392,7 @@
 
 	duk_insert_undefined(thr, idx_func + 1);
 
-	call_flags = 0;  /* not protected, respect reclimit, not constructor */
+	call_flags = 0; /* not protected, respect reclimit, not constructor */
 	duk_handle_call_unprotected(thr, idx_func, call_flags);
 }
 
@@ -14702,7 +15405,7 @@
 	idx_func = duk__call_get_idx_func(thr, nargs, 2);
 	DUK_ASSERT(duk_is_valid_index(thr, idx_func));
 
-	call_flags = 0;  /* not protected, respect reclimit, not constructor */
+	call_flags = 0; /* not protected, respect reclimit, not constructor */
 	duk_handle_call_unprotected(thr, idx_func, call_flags);
 }
 
@@ -14716,7 +15419,7 @@
 
 	DUK_ASSERT_API_ENTRY(thr);
 
-	obj_idx = duk_require_normalize_index(thr, obj_idx);  /* make absolute */
+	obj_idx = duk_require_normalize_index(thr, obj_idx); /* make absolute */
 	if (DUK_UNLIKELY(nargs < 0)) {
 		DUK_ERROR_TYPE_INVALID_ARGS(thr);
 		DUK_WO_NORETURN(return;);
@@ -14814,7 +15517,7 @@
 
 	args = (duk__pcall_prop_args *) udata;
 
-	obj_idx = duk_require_normalize_index(thr, args->obj_idx);  /* make absolute */
+	obj_idx = duk_require_normalize_index(thr, args->obj_idx); /* make absolute */
 	duk__call_prop_prep_stack(thr, obj_idx, args->nargs);
 
 	ret = duk_handle_call_unprotected_nargs(thr, args->nargs, args->call_flags);
@@ -14852,30 +15555,30 @@
 	 */
 	/* XXX: check for any reserve? */
 
-	if (DUK_UNLIKELY((nargs | nrets) < 0 ||  /* nargs < 0 || nrets < 0; OR sign bits */
-	                 thr->valstack_top < thr->valstack_bottom + nargs ||        /* nargs too large compared to top */
-	                 thr->valstack_end + nargs < thr->valstack_top + nrets)) {  /* nrets too large compared to reserve */
+	if (DUK_UNLIKELY((nargs | nrets) < 0 || /* nargs < 0 || nrets < 0; OR sign bits */
+	                 thr->valstack_top < thr->valstack_bottom + nargs || /* nargs too large compared to top */
+	                 thr->valstack_end + nargs < thr->valstack_top + nrets)) { /* nrets too large compared to reserve */
 		DUK_D(DUK_DPRINT("not enough stack reserve for safe call or invalid arguments: "
 		                 "nargs=%ld < 0 (?), nrets=%ld < 0 (?), top=%ld < bottom=%ld + nargs=%ld (?), "
 		                 "end=%ld + nargs=%ld < top=%ld + nrets=%ld (?)",
-		                  (long) nargs,
-		                  (long) nrets,
-		                  (long) (thr->valstack_top - thr->valstack),
-		                  (long) (thr->valstack_bottom - thr->valstack),
-		                  (long) nargs,
-		                  (long) (thr->valstack_end - thr->valstack),
-		                  (long) nargs,
-		                  (long) (thr->valstack_top - thr->valstack),
-		                  (long) nrets));
+		                 (long) nargs,
+		                 (long) nrets,
+		                 (long) (thr->valstack_top - thr->valstack),
+		                 (long) (thr->valstack_bottom - thr->valstack),
+		                 (long) nargs,
+		                 (long) (thr->valstack_end - thr->valstack),
+		                 (long) nargs,
+		                 (long) (thr->valstack_top - thr->valstack),
+		                 (long) nrets));
 		DUK_ERROR_TYPE_INVALID_ARGS(thr);
 		DUK_WO_NORETURN(return DUK_EXEC_ERROR;);
 	}
 
-	rc = duk_handle_safe_call(thr,           /* thread */
-	                          func,          /* func */
-	                          udata,         /* udata */
-	                          nargs,         /* num_stack_args */
-	                          nrets);        /* num_stack_res */
+	rc = duk_handle_safe_call(thr, /* thread */
+	                          func, /* func */
+	                          udata, /* udata */
+	                          nargs, /* num_stack_args */
+	                          nrets); /* num_stack_res */
 
 	return rc;
 }
@@ -14888,7 +15591,7 @@
 	idx_func = duk__call_get_idx_func(thr, nargs, 1);
 	DUK_ASSERT(duk_is_valid_index(thr, idx_func));
 
-	duk_push_object(thr);  /* default instance; internal proto updated by call handling */
+	duk_push_object(thr); /* default instance; internal proto updated by call handling */
 	duk_insert(thr, idx_func + 1);
 
 	duk_handle_call_unprotected(thr, idx_func, DUK_CALL_FLAG_CONSTRUCT);
@@ -15016,7 +15719,7 @@
 	}
 
 	/* fall through */
- type_error:
+type_error:
 	DUK_ERROR_TYPE(thr, DUK_STR_UNEXPECTED_TYPE);
 	DUK_WO_NORETURN(return 0;);
 }
@@ -15091,15 +15794,16 @@
  * is guaranteed to be non-NULL, even for zero length input.
  */
 DUK_LOCAL const duk_uint8_t *duk__prep_codec_arg(duk_hthread *thr, duk_idx_t idx, duk_size_t *out_len) {
-	const void *def_ptr = (const void *) out_len;  /* Any non-NULL pointer will do. */
+	const void *def_ptr = (const void *) out_len; /* Any non-NULL pointer will do. */
 	const void *ptr;
 	duk_bool_t isbuffer;
 
 	DUK_ASSERT(out_len != NULL);
 	DUK_ASSERT(def_ptr != NULL);
-	DUK_ASSERT(duk_is_valid_index(thr, idx));  /* checked by caller */
+	DUK_ASSERT(duk_is_valid_index(thr, idx)); /* checked by caller */
 
-	ptr = (const void *) duk_get_buffer_data_raw(thr, idx, out_len, NULL /*def_ptr*/, 0 /*def_size*/, 0 /*throw_flag*/, &isbuffer);
+	ptr = (const void *)
+	    duk_get_buffer_data_raw(thr, idx, out_len, NULL /*def_ptr*/, 0 /*def_size*/, 0 /*throw_flag*/, &isbuffer);
 	if (isbuffer) {
 		DUK_ASSERT(ptr != NULL || *out_len == 0U);
 		if (DUK_UNLIKELY(ptr == NULL)) {
@@ -15124,21 +15828,21 @@
 #if defined(DUK_USE_BASE64_SUPPORT)
 /* Bytes emitted for number of padding characters in range [0,4]. */
 DUK_LOCAL const duk_int8_t duk__base64_decode_nequal_step[5] = {
-	3,   /* #### -> 24 bits, emit 3 bytes */
-	2,   /* ###= -> 18 bits, emit 2 bytes */
-	1,   /* ##== -> 12 bits, emit 1 byte */
-	-1,  /* #=== -> 6 bits, error */
-	0,   /* ==== -> 0 bits, emit 0 bytes */
+	3, /* #### -> 24 bits, emit 3 bytes */
+	2, /* ###= -> 18 bits, emit 2 bytes */
+	1, /* ##== -> 12 bits, emit 1 byte */
+	-1, /* #=== -> 6 bits, error */
+	0, /* ==== -> 0 bits, emit 0 bytes */
 };
 
 #if defined(DUK_USE_BASE64_FASTPATH)
 DUK_LOCAL const duk_uint8_t duk__base64_enctab_fast[64] = {
-	0x41U, 0x42U, 0x43U, 0x44U, 0x45U, 0x46U, 0x47U, 0x48U, 0x49U, 0x4aU, 0x4bU, 0x4cU, 0x4dU, 0x4eU, 0x4fU, 0x50U,  /* A...P */
-	0x51U, 0x52U, 0x53U, 0x54U, 0x55U, 0x56U, 0x57U, 0x58U, 0x59U, 0x5aU, 0x61U, 0x62U, 0x63U, 0x64U, 0x65U, 0x66U,  /* Q...f */
-	0x67U, 0x68U, 0x69U, 0x6aU, 0x6bU, 0x6cU, 0x6dU, 0x6eU, 0x6fU, 0x70U, 0x71U, 0x72U, 0x73U, 0x74U, 0x75U, 0x76U,  /* g...v */
-	0x77U, 0x78U, 0x79U, 0x7aU, 0x30U, 0x31U, 0x32U, 0x33U, 0x34U, 0x35U, 0x36U, 0x37U, 0x38U, 0x39U, 0x2bU, 0x2fU   /* w.../ */
+	0x41U, 0x42U, 0x43U, 0x44U, 0x45U, 0x46U, 0x47U, 0x48U, 0x49U, 0x4aU, 0x4bU, 0x4cU, 0x4dU, 0x4eU, 0x4fU, 0x50U, /* A...P */
+	0x51U, 0x52U, 0x53U, 0x54U, 0x55U, 0x56U, 0x57U, 0x58U, 0x59U, 0x5aU, 0x61U, 0x62U, 0x63U, 0x64U, 0x65U, 0x66U, /* Q...f */
+	0x67U, 0x68U, 0x69U, 0x6aU, 0x6bU, 0x6cU, 0x6dU, 0x6eU, 0x6fU, 0x70U, 0x71U, 0x72U, 0x73U, 0x74U, 0x75U, 0x76U, /* g...v */
+	0x77U, 0x78U, 0x79U, 0x7aU, 0x30U, 0x31U, 0x32U, 0x33U, 0x34U, 0x35U, 0x36U, 0x37U, 0x38U, 0x39U, 0x2bU, 0x2fU /* w.../ */
 };
-#endif  /* DUK_USE_BASE64_FASTPATH */
+#endif /* DUK_USE_BASE64_FASTPATH */
 
 #if defined(DUK_USE_BASE64_FASTPATH)
 /* Decode table for one byte of input:
@@ -15148,24 +15852,24 @@
  *    0...63 decoded bytes
  */
 DUK_LOCAL const duk_int8_t duk__base64_dectab_fast[256] = {
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -1, -1, -3, -3, -1, -3, -3,  /* 0x00...0x0f */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,  /* 0x10...0x1f */
-	-1, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 62, -3, -3, -3, 63,  /* 0x20...0x2f */
-	52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -3, -3, -3, -2, -3, -3,  /* 0x30...0x3f */
-	-3,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,  /* 0x40...0x4f */
-	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -3, -3, -3, -3, -3,  /* 0x50...0x5f */
-	-3, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,  /* 0x60...0x6f */
-	41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -3, -3, -3, -3, -3,  /* 0x70...0x7f */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,  /* 0x80...0x8f */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,  /* 0x90...0x9f */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,  /* 0xa0...0xaf */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,  /* 0xb0...0xbf */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,  /* 0xc0...0xcf */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,  /* 0xd0...0xdf */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,  /* 0xe0...0xef */
-	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3   /* 0xf0...0xff */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -1, -1, -3, -3, -1, -3, -3, /* 0x00...0x0f */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* 0x10...0x1f */
+	-1, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, 62, -3, -3, -3, 63, /* 0x20...0x2f */
+	52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -3, -3, -3, -2, -3, -3, /* 0x30...0x3f */
+	-3, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, /* 0x40...0x4f */
+	15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -3, -3, -3, -3, -3, /* 0x50...0x5f */
+	-3, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60...0x6f */
+	41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -3, -3, -3, -3, -3, /* 0x70...0x7f */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* 0x80...0x8f */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* 0x90...0x9f */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* 0xa0...0xaf */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* 0xb0...0xbf */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* 0xc0...0xcf */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* 0xd0...0xdf */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, /* 0xe0...0xef */
+	-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3 /* 0xf0...0xff */
 };
-#endif  /* DUK_USE_BASE64_FASTPATH */
+#endif /* DUK_USE_BASE64_FASTPATH */
 
 #if defined(DUK_USE_BASE64_FASTPATH)
 DUK_LOCAL DUK_ALWAYS_INLINE void duk__base64_encode_fast_3(const duk_uint8_t *src, duk_uint8_t *dst) {
@@ -15197,9 +15901,9 @@
 
 	t = (duk_uint_t) src[0];
 	t = (t << 8) + (duk_uint_t) src[1];
-	dst[0] = duk__base64_enctab_fast[t >> 10];           /* XXXXXX-- -------- */
-	dst[1] = duk__base64_enctab_fast[(t >> 4) & 0x3fU];  /* ------XX XXXX---- */
-	dst[2] = duk__base64_enctab_fast[(t << 2) & 0x3fU];  /* -------- ----XXXX */
+	dst[0] = duk__base64_enctab_fast[t >> 10]; /* XXXXXX-- -------- */
+	dst[1] = duk__base64_enctab_fast[(t >> 4) & 0x3fU]; /* ------XX XXXX---- */
+	dst[2] = duk__base64_enctab_fast[(t << 2) & 0x3fU]; /* -------- ----XXXX */
 	dst[3] = DUK_ASC_EQUALS;
 }
 
@@ -15207,8 +15911,8 @@
 	duk_uint_t t;
 
 	t = (duk_uint_t) src[0];
-	dst[0] = duk__base64_enctab_fast[t >> 2];            /* XXXXXX-- */
-	dst[1] = duk__base64_enctab_fast[(t << 4) & 0x3fU];  /* ------XX */
+	dst[0] = duk__base64_enctab_fast[t >> 2]; /* XXXXXX-- */
+	dst[1] = duk__base64_enctab_fast[(t << 4) & 0x3fU]; /* ------XX */
 	dst[2] = DUK_ASC_EQUALS;
 	dst[3] = DUK_ASC_EQUALS;
 }
@@ -15256,24 +15960,24 @@
 	DUK_ASSERT(n == 0U || n == 1U || n == 2U);
 	if (n == 1U) {
 		duk__base64_encode_fast_1(p, q);
-#if 0  /* Unnecessary. */
+#if 0 /* Unnecessary. */
 		p += 1;
 		q += 4;
 		n -= 1U;
 #endif
 	} else if (n == 2U) {
 		duk__base64_encode_fast_2(p, q);
-#if 0  /* Unnecessary. */
+#if 0 /* Unnecessary. */
 		p += 2;
 		q += 4;
 		n -= 2U;
 #endif
 	} else {
-		DUK_ASSERT(n == 0U);  /* nothing to do */
+		DUK_ASSERT(n == 0U); /* nothing to do */
 		;
 	}
 }
-#else  /* DUK_USE_BASE64_FASTPATH */
+#else /* DUK_USE_BASE64_FASTPATH */
 DUK_LOCAL void duk__base64_encode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst) {
 	duk_small_uint_t i, npad;
 	duk_uint_t t, x, y;
@@ -15345,10 +16049,13 @@
 		npad--;
 	}
 }
-#endif  /* DUK_USE_BASE64_FASTPATH */
+#endif /* DUK_USE_BASE64_FASTPATH */
 
 #if defined(DUK_USE_BASE64_FASTPATH)
-DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst, duk_uint8_t **out_dst_final) {
+DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src,
+                                               duk_size_t srclen,
+                                               duk_uint8_t *dst,
+                                               duk_uint8_t **out_dst_final) {
 	duk_int_t x;
 	duk_uint_t t;
 	duk_small_uint_t n_equal;
@@ -15358,11 +16065,11 @@
 	const duk_uint8_t *p_end_safe;
 	duk_uint8_t *q;
 
-	DUK_ASSERT(src != NULL);  /* Required by pointer arithmetic below, which fails for NULL. */
+	DUK_ASSERT(src != NULL); /* Required by pointer arithmetic below, which fails for NULL. */
 
 	p = src;
 	p_end = src + srclen;
-	p_end_safe = p_end - 8;  /* If 'src <= src_end_safe', safe to read 8 bytes. */
+	p_end_safe = p_end - 8; /* If 'src <= src_end_safe', safe to read 8 bytes. */
 	q = dst;
 
 	/* Alternate between a fast path which processes clean groups with no
@@ -15392,7 +16099,9 @@
 			 * bytes to minimize aliasing.
 			 */
 			DUK_DDD(DUK_DDDPRINT("fast loop: p=%p, p_end_safe=%p, p_end=%p",
-			                     (const void *) p, (const void *) p_end_safe, (const void *) p_end));
+			                     (const void *) p,
+			                     (const void *) p_end_safe,
+			                     (const void *) p_end));
 
 			t1 = (duk_int_t) duk__base64_dectab_fast[p[0]];
 			t1 = (duk_int_t) ((duk_uint_t) t1 << 6) | (duk_int_t) duk__base64_dectab_fast[p[1]];
@@ -15417,17 +16126,19 @@
 				p += 8;
 				q += 6;
 			} else if (t1 >= 0) {
-				DUK_DDD(DUK_DDDPRINT("fast loop first group was clean, second was not, process one slow path group"));
+				DUK_DDD(
+				    DUK_DDDPRINT("fast loop first group was clean, second was not, process one slow path group"));
 				DUK_ASSERT(t2 < 0);
 				p += 4;
 				q += 3;
 				break;
 			} else {
-				DUK_DDD(DUK_DDDPRINT("fast loop first group was not clean, second does not matter, process one slow path group"));
+				DUK_DDD(DUK_DDDPRINT(
+				    "fast loop first group was not clean, second does not matter, process one slow path group"));
 				DUK_ASSERT(t1 < 0);
 				break;
 			}
-		}  /* fast path */
+		} /* fast path */
 
 		/* Slow path step 1: try to scan a 4-character encoded group,
 		 * end-of-input, or start-of-padding.  We exit with:
@@ -15442,7 +16153,9 @@
 		t = 1UL;
 		for (;;) {
 			DUK_DDD(DUK_DDDPRINT("slow loop: p=%p, p_end=%p, t=%lu",
-			                     (const void *) p, (const void *) p_end, (unsigned long) t));
+			                     (const void *) p,
+			                     (const void *) p_end,
+			                     (unsigned long) t));
 
 			if (DUK_LIKELY(p < p_end)) {
 				x = duk__base64_dectab_fast[*p++];
@@ -15453,18 +16166,18 @@
 						break;
 					}
 				} else if (x == -1) {
-					continue;  /* allowed ascii whitespace */
+					continue; /* allowed ascii whitespace */
 				} else if (x == -2) {
 					p--;
-					break;  /* start of padding */
+					break; /* start of padding */
 				} else {
 					DUK_ASSERT(x == -3);
 					goto decode_error;
 				}
 			} else {
-				break;  /* end of input */
+				break; /* end of input */
 			}
-		}  /* slow path step 1 */
+		} /* slow path step 1 */
 
 		/* Complete the padding by simulating pad characters,
 		 * regardless of actual input padding chars.
@@ -15523,28 +16236,30 @@
 			}
 			x = duk__base64_dectab_fast[*p++];
 			if (x == -1 || x == -2) {
-				;  /* padding or whitespace, keep eating */
+				; /* padding or whitespace, keep eating */
 			} else {
 				p--;
-				break;  /* backtrack and go back to fast path, even for -1 */
+				break; /* backtrack and go back to fast path, even for -1 */
 			}
-		}  /* slow path step 3 */
-	}  /* outer fast+slow path loop */
+		} /* slow path step 3 */
+	} /* outer fast+slow path loop */
 
- done:
-	DUK_DDD(DUK_DDDPRINT("done; p=%p, p_end=%p",
-	                     (const void *) p, (const void *) p_end));
+done:
+	DUK_DDD(DUK_DDDPRINT("done; p=%p, p_end=%p", (const void *) p, (const void *) p_end));
 
 	DUK_ASSERT(p == p_end);
 
 	*out_dst_final = q;
 	return 1;
 
- decode_error:
+decode_error:
 	return 0;
 }
-#else  /* DUK_USE_BASE64_FASTPATH */
-DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src, duk_size_t srclen, duk_uint8_t *dst, duk_uint8_t **out_dst_final) {
+#else /* DUK_USE_BASE64_FASTPATH */
+DUK_LOCAL duk_bool_t duk__base64_decode_helper(const duk_uint8_t *src,
+                                               duk_size_t srclen,
+                                               duk_uint8_t *dst,
+                                               duk_uint8_t **out_dst_final) {
 	duk_uint_t t, x;
 	duk_int_t y;
 	duk_int8_t step;
@@ -15630,7 +16345,7 @@
 		} else {
 			/* Valid: whitespace. */
 			duk_uint32_t m;
-			DUK_ASSERT(x < 0x20U);  /* 0x00 to 0x1f */
+			DUK_ASSERT(x < 0x20U); /* 0x00 to 0x1f */
 			m = (1U << x);
 			if (mask_white & m) {
 				/* Allow basic ASCII whitespace. */
@@ -15647,7 +16362,7 @@
 		}
 		/* fall through; no padding will be added */
 
-	 simulate_padding:
+	simulate_padding:
 		n_equal = 0;
 		while (t < 0x1000000UL) {
 			t = (t << 6) + 0U;
@@ -15679,10 +16394,10 @@
 	*out_dst_final = q;
 	return 1;
 
- decode_error:
+decode_error:
 	return 0;
 }
-#endif  /* DUK_USE_BASE64_FASTPATH */
+#endif /* DUK_USE_BASE64_FASTPATH */
 
 DUK_EXTERNAL const char *duk_base64_encode(duk_hthread *thr, duk_idx_t idx) {
 	const duk_uint8_t *src;
@@ -15711,11 +16426,11 @@
 
 	duk__base64_encode_helper((const duk_uint8_t *) src, srclen, dst);
 
-	ret = duk_buffer_to_string(thr, -1);  /* Safe, result is ASCII. */
+	ret = duk_buffer_to_string(thr, -1); /* Safe, result is ASCII. */
 	duk_replace(thr, idx);
 	return ret;
 
- type_error:
+type_error:
 	DUK_ERROR_TYPE(thr, DUK_STR_BASE64_ENCODE_FAILED);
 	DUK_WO_NORETURN(return NULL;);
 }
@@ -15740,7 +16455,7 @@
 	 * Similarly, 'xx' may ecause 1+3 = bytes to be emitted and then
 	 * backtracked.
 	 */
-	dstlen = (srclen / 4) * 3 + 6;  /* upper limit, assuming no whitespace etc */
+	dstlen = (srclen / 4) * 3 + 6; /* upper limit, assuming no whitespace etc */
 	dst = (duk_uint8_t *) duk_push_dynamic_buffer(thr, dstlen);
 	/* Note: for dstlen=0, dst may be NULL */
 
@@ -15753,11 +16468,11 @@
 	duk_replace(thr, idx);
 	return;
 
- type_error:
+type_error:
 	DUK_ERROR_TYPE(thr, DUK_STR_BASE64_DECODE_FAILED);
 	DUK_WO_NORETURN(return;);
 }
-#else  /* DUK_USE_BASE64_SUPPORT */
+#else /* DUK_USE_BASE64_SUPPORT */
 DUK_EXTERNAL const char *duk_base64_encode(duk_hthread *thr, duk_idx_t idx) {
 	DUK_UNREF(idx);
 	DUK_ERROR_UNSUPPORTED(thr);
@@ -15769,7 +16484,7 @@
 	DUK_ERROR_UNSUPPORTED(thr);
 	DUK_WO_NORETURN(return;);
 }
-#endif  /* DUK_USE_BASE64_SUPPORT */
+#endif /* DUK_USE_BASE64_SUPPORT */
 
 /*
  *  Hex
@@ -15798,7 +16513,7 @@
 	DUK_ASSERT(buf != NULL);
 
 #if defined(DUK_USE_HEX_FASTPATH)
-	DUK_ASSERT((((duk_size_t) buf) & 0x01U) == 0);   /* pointer is aligned, guaranteed for fixed buffer */
+	DUK_ASSERT((((duk_size_t) buf) & 0x01U) == 0); /* pointer is aligned, guaranteed for fixed buffer */
 	p16 = (duk_uint16_t *) (void *) buf;
 	len_safe = len & ~0x03U;
 	for (i = 0; i < len_safe; i += 4) {
@@ -15811,14 +16526,14 @@
 	for (; i < len; i++) {
 		*p16++ = duk_hex_enctab[inp[i]];
 	}
-#else  /* DUK_USE_HEX_FASTPATH */
+#else /* DUK_USE_HEX_FASTPATH */
 	for (i = 0; i < len; i++) {
 		duk_small_uint_t t;
 		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];
+		buf[i * 2 + 0] = duk_lc_digits[t >> 4];
+		buf[i * 2 + 1] = duk_lc_digits[t & 0x0f];
 	}
-#endif  /* DUK_USE_HEX_FASTPATH */
+#endif /* DUK_USE_HEX_FASTPATH */
 
 	/* XXX: Using a string return value forces a string intern which is
 	 * not always necessary.  As a rough performance measure, hex encode
@@ -15827,7 +16542,7 @@
 	 * caller coerce to string if necessary?
 	 */
 
-	ret = duk_buffer_to_string(thr, -1);  /* Safe, result is ASCII. */
+	ret = duk_buffer_to_string(thr, -1); /* Safe, result is ASCII. */
 	duk_replace(thr, idx);
 	return ret;
 }
@@ -15862,20 +16577,16 @@
 	p = buf;
 	len_safe = len & ~0x07U;
 	for (i = 0; i < len_safe; i += 8) {
-		t = ((duk_int_t) duk_hex_dectab_shift4[inp[i]]) |
-		    ((duk_int_t) duk_hex_dectab[inp[i + 1]]);
+		t = ((duk_int_t) duk_hex_dectab_shift4[inp[i]]) | ((duk_int_t) duk_hex_dectab[inp[i + 1]]);
 		chk = t;
 		p[0] = (duk_uint8_t) t;
-		t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 2]]) |
-		    ((duk_int_t) duk_hex_dectab[inp[i + 3]]);
+		t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 2]]) | ((duk_int_t) duk_hex_dectab[inp[i + 3]]);
 		chk |= t;
 		p[1] = (duk_uint8_t) t;
-		t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 4]]) |
-		    ((duk_int_t) duk_hex_dectab[inp[i + 5]]);
+		t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 4]]) | ((duk_int_t) duk_hex_dectab[inp[i + 5]]);
 		chk |= t;
 		p[2] = (duk_uint8_t) t;
-		t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 6]]) |
-		    ((duk_int_t) duk_hex_dectab[inp[i + 7]]);
+		t = ((duk_int_t) duk_hex_dectab_shift4[inp[i + 6]]) | ((duk_int_t) duk_hex_dectab[inp[i + 7]]);
 		chk |= t;
 		p[3] = (duk_uint8_t) t;
 		p += 4;
@@ -15897,7 +16608,7 @@
 		}
 		*p++ = (duk_uint8_t) t;
 	}
-#else  /* DUK_USE_HEX_FASTPATH */
+#else /* DUK_USE_HEX_FASTPATH */
 	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
@@ -15910,16 +16621,16 @@
 		}
 		buf[i >> 1] = (duk_uint8_t) t;
 	}
-#endif  /* DUK_USE_HEX_FASTPATH */
+#endif /* DUK_USE_HEX_FASTPATH */
 
 	duk_replace(thr, idx);
 	return;
 
- type_error:
+type_error:
 	DUK_ERROR_TYPE(thr, DUK_STR_HEX_DECODE_FAILED);
 	DUK_WO_NORETURN(return;);
 }
-#else  /* DUK_USE_HEX_SUPPORT */
+#else /* DUK_USE_HEX_SUPPORT */
 DUK_EXTERNAL const char *duk_hex_encode(duk_hthread *thr, duk_idx_t idx) {
 	DUK_UNREF(idx);
 	DUK_ERROR_UNSUPPORTED(thr);
@@ -15930,7 +16641,7 @@
 	DUK_ERROR_UNSUPPORTED(thr);
 	DUK_WO_NORETURN(return;);
 }
-#endif  /* DUK_USE_HEX_SUPPORT */
+#endif /* DUK_USE_HEX_SUPPORT */
 
 /*
  *  JSON
@@ -15974,15 +16685,12 @@
 #endif
 
 	idx = duk_require_normalize_index(thr, idx);
-	duk_bi_json_parse_helper(thr,
-	                         idx /*idx_value*/,
-	                         DUK_INVALID_INDEX /*idx_reviver*/,
-	                         0 /*flags*/);
+	duk_bi_json_parse_helper(thr, idx /*idx_value*/, DUK_INVALID_INDEX /*idx_reviver*/, 0 /*flags*/);
 	duk_replace(thr, idx);
 
 	DUK_ASSERT(duk_get_top(thr) == top_at_entry);
 }
-#else  /* DUK_USE_JSON_SUPPORT */
+#else /* DUK_USE_JSON_SUPPORT */
 DUK_EXTERNAL const char *duk_json_encode(duk_hthread *thr, duk_idx_t idx) {
 	DUK_ASSERT_API_ENTRY(thr);
 	DUK_UNREF(idx);
@@ -15996,7 +16704,7 @@
 	DUK_ERROR_UNSUPPORTED(thr);
 	DUK_WO_NORETURN(return;);
 }
-#endif  /* DUK_USE_JSON_SUPPORT */
+#endif /* DUK_USE_JSON_SUPPORT */
 #line 1 "duk_api_compile.c"
 /*
  *  Compilation and evaluation
@@ -16006,7 +16714,7 @@
 
 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 */
+	duk_size_t src_length; /* should be first on 64-bit platforms */
 	const duk_uint8_t *src_buffer;
 	duk_uint_t flags;
 };
@@ -16026,7 +16734,10 @@
 
 	/* [ ... source? filename? ] (depends on flags) */
 
-	rc = duk_compile_raw(thr, src_buffer, src_length, flags | DUK_COMPILE_EVAL);  /* may be safe, or non-safe depending on flags */
+	rc = duk_compile_raw(thr,
+	                     src_buffer,
+	                     src_length,
+	                     flags | DUK_COMPILE_EVAL); /* may be safe, or non-safe depending on flags */
 
 	/* [ ... closure/error ] */
 
@@ -16035,7 +16746,7 @@
 		goto got_rc;
 	}