visaljs 0.0.9 → 0.0.11

package/node/third_party/c-ares/src/lib/util/ares_uri.h

@@ -0,0 +1,252 @@
+/* MIT License
+ *
+ * Copyright (c) 2024 Brad House
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#ifndef __ARES_URI_H
+#define __ARES_URI_H
+
+/*! \addtogroup ares_uri URI parser and writer implementation
+ *
+ * This is a fairly complete URI parser and writer implementation (RFC 3986) for
+ * schemes which use the :// syntax. Does not currently support URIs without an
+ * authority section, such as "mailto:person@example.com".
+ *
+ * Its implementation is overkill for our current needs to be able to express
+ * DNS server configuration, but there was really no reason not to support
+ * a greater subset of the specification.
+ *
+ * @{
+ */
+
+
+struct ares_uri;
+
+/*! URI object */
+typedef struct ares_uri ares_uri_t;
+
+/*! Create a new URI object
+ *
+ *  \return new ares_uri_t, must be freed with ares_uri_destroy()
+ */
+ares_uri_t             *ares_uri_create(void);
+
+/*! Destroy an initialized URI object
+ *
+ *  \param[in] uri  Initialized URI object
+ */
+void                    ares_uri_destroy(ares_uri_t *uri);
+
+/*! Set the URI scheme.  Automatically lower-cases the scheme provided.
+ *  Only allows Alpha, Digit, +, -, and . characters.  Maximum length is
+ *  15 characters.  This is required to be set to write a URI.
+ *
+ *  \param[in] uri    Initialized URI object
+ *  \param[in] scheme Scheme to set the object to use
+ *  \return ARES_SUCCESS on success
+ */
+ares_status_t  ares_uri_set_scheme(ares_uri_t *uri, const char *scheme);
+
+/*! Retrieve the currently configured URI scheme.
+ *
+ *  \param[in] uri    Initialized URI object
+ *  \return string containing URI scheme
+ */
+const char    *ares_uri_get_scheme(const ares_uri_t *uri);
+
+/*! Set the username in the URI object
+ *
+ *  \param[in] uri      Initialized URI object
+ *  \param[in] username Username to set. May be NULL to unset existing username.
+ *  \return ARES_SUCCESS on success
+ */
+ares_status_t  ares_uri_set_username(ares_uri_t *uri, const char *username);
+
+/*! Retrieve the currently configured username.
+ *
+ *  \param[in] uri    Initialized URI object
+ *  \return string containing username, maybe NULL if not set.
+ */
+const char    *ares_uri_get_username(const ares_uri_t *uri);
+
+/*! Set the password in the URI object
+ *
+ *  \param[in] uri      Initialized URI object
+ *  \param[in] password Password to set. May be NULL to unset existing password.
+ *  \return ARES_SUCCESS on success
+ */
+ares_status_t  ares_uri_set_password(ares_uri_t *uri, const char *password);
+
+/*! Retrieve the currently configured password.
+ *
+ *  \param[in] uri    Initialized URI object
+ *  \return string containing password, maybe NULL if not set.
+ */
+const char    *ares_uri_get_password(const ares_uri_t *uri);
+
+/*! Set the host or ip address in the URI object.  This is required to be
+ *  set to write a URI.  The character set is strictly validated.
+ *
+ *  \param[in] uri      Initialized URI object
+ *  \param[in] host     IPv4, IPv6, or hostname to set.
+ *  \return ARES_SUCCESS on success
+ */
+ares_status_t  ares_uri_set_host(ares_uri_t *uri, const char *host);
+
+/*! Retrieve the currently configured host (or ip address).  IPv6 addresses
+ *  May include a link-local scope (e.g. fe80::b542:84df:1719:65e3%en0).
+ *
+ *  \param[in] uri    Initialized URI object
+ *  \return string containing host, maybe NULL if not set.
+ */
+const char    *ares_uri_get_host(const ares_uri_t *uri);
+
+/*! Set the port to use in the URI object.  A port value of 0 will omit
+ *  the port from the URI when written, thus using the scheme's default.
+ *
+ *  \param[in] uri  Initialized URI object
+ *  \param[in] port Port to set. Use 0 to unset.
+ *  \return ARES_SUCCESS on success
+ */
+ares_status_t  ares_uri_set_port(ares_uri_t *uri, unsigned short port);
+
+/*! Retrieve the currently configured port
+ *
+ *  \param[in] uri    Initialized URI object
+ *  \return port number, or 0 if not set.
+ */
+unsigned short ares_uri_get_port(const ares_uri_t *uri);
+
+/*! Set the path in the URI object.  Unsupported characters will be URI-encoded
+ *  when written.
+ *
+ *  \param[in] uri  Initialized URI object
+ *  \param[in] path Path to set. May be NULL to unset existing path.
+ *  \return ARES_SUCCESS on success
+ */
+ares_status_t  ares_uri_set_path(ares_uri_t *uri, const char *path);
+
+/*! Retrieves the path in the URI object.  If retrieved after parse, this
+ *  value will be URI-decoded already.
+ *
+ *  \param[in] uri Initialized URI object
+ *  \return path string, or NULL if not set.
+ */
+const char    *ares_uri_get_path(const ares_uri_t *uri);
+
+/*! Set a new query key/value pair.  There is no set order for query keys
+ *  when output in the URI, they will be emitted in a random order.  Keys are
+ *  case-insensitive. Query keys and values will be automatically URI-encoded
+ *  when written.
+ *
+ *  \param[in] uri  Initialized URI object
+ *  \param[in] key  Query key to use, must be non-zero length.
+ *  \param[in] val  Query value to use, may be NULL.
+ *  \return ARES_SUCCESS on success
+ */
+ares_status_t  ares_uri_set_query_key(ares_uri_t *uri, const char *key,
+                                      const char *val);
+
+/*! Delete a specific query key.
+ *
+ *  \param[in] uri Initialized URI object
+ *  \param[in] key Key to delete.
+ *  \return ARES_SUCCESS if deleted, ARES_ENOTFOUND if not found
+ */
+ares_status_t  ares_uri_del_query_key(ares_uri_t *uri, const char *key);
+
+/*! Retrieve the value associated with a query key. Keys are case-insensitive.
+ *
+ *  \param[in] uri Initialized URI object
+ *  \param[in] key Key to retrieve.
+ *  \return string representing value, may be NULL if either not found or
+ *          NULL value set.  There is currently no way to indicate the
+ *          difference.
+ */
+const char    *ares_uri_get_query_key(const ares_uri_t *uri, const char *key);
+
+/*! Retrieve a complete list of query keys.
+ *
+ *  \param[in]  uri Initialized URI object
+ *  \param[out] num Number of keys.
+ *  \return NULL on failure or no keys. Use
+ *          ares_free_array(keys, num, ares_free) when done with array.
+ */
+char         **ares_uri_get_query_keys(const ares_uri_t *uri, size_t *num);
+
+/*! Set the fragment in the URI object.  Unsupported characters will be
+ *  URI-encoded when written.
+ *
+ *  \param[in] uri      Initialized URI object
+ *  \param[in] fragment Fragment to set. May be NULL to unset existing fragment.
+ *  \return ARES_SUCCESS on success
+ */
+ares_status_t  ares_uri_set_fragment(ares_uri_t *uri, const char *fragment);
+
+/*! Retrieves the fragment in the URI object.  If retrieved after parse, this
+ *  value will be URI-decoded already.
+ *
+ *  \param[in] uri Initialized URI object
+ *  \return fragment string, or NULL if not set.
+ */
+const char    *ares_uri_get_fragment(const ares_uri_t *uri);
+
+/*! Parse the provided URI buffer into a new URI object.
+ *
+ *  \param[out] out  Returned new URI object. free with ares_uri_destroy().
+ *  \param[in]  buf  Buffer object containing the URI
+ *  \return ARES_SUCCESS on successful parse. On failure the 'buf' object will
+ *          be restored to its initial state in case another parser needs to
+ *          be attempted.
+ */
+ares_status_t  ares_uri_parse_buf(ares_uri_t **out, ares_buf_t *buf);
+
+/*! Parse the provided URI string into a new URI object.
+ *
+ *  \param[out] out  Returned new URI object. free with ares_uri_destroy().
+ *  \param[in]  uri  URI string to parse
+ *  \return ARES_SUCCESS on successful parse
+ */
+ares_status_t  ares_uri_parse(ares_uri_t **out, const char *uri);
+
+/*! Write URI object to a new string buffer.  Requires at least the scheme
+ *  and host to be set for this to succeed.
+ *
+ *  \param[out] out  Returned new URI string. Free with ares_free().
+ *  \param[in]  uri  Initialized URI object.
+ *  \return ARES_SUCCESS on successful write.
+ */
+ares_status_t  ares_uri_write(char **out, const ares_uri_t *uri);
+
+/*! Write URI object to an existing ares_buf_t object.  Requires at least the
+ *  scheme and host to be set for this to succeed.
+ *
+ *  \param[in]     uri  Initialized URI object.
+ *  \param[in,out] buf  Destination buf object.
+ *  \return ARES_SUCCESS on successful write.
+ */
+ares_status_t  ares_uri_write_buf(const ares_uri_t *uri, ares_buf_t *buf);
+
+/*! @} */
+
+#endif /* __ARES_URI_H */

package/node/third_party/c-ares/src/lib/windows_port.c

@@ -0,0 +1,29 @@
+/**********************************************************************
+ *
+ * Copyright (c) 1998 Massachusetts Institute of Technology
+ * Copyright (C) Daniel Stenberg
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+#include "ares_private.h"
+
+
+/* only do the following on windows
+ */
+#if defined(_WIN32) && !defined(MSDOS)
+
+#  ifdef __WATCOMC__
+/*
+ * Watcom needs a DllMain() in order to initialise the clib startup code.
+ */
+BOOL WINAPI DllMain(HINSTANCE hnd, DWORD reason, LPVOID reserved)
+{
+  (void)hnd;
+  (void)reason;
+  (void)reserved;
+  return (TRUE);
+}
+#  endif
+
+#endif /* WIN32 builds only */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "visaljs",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Ahead-of-time JavaScript to C compiler: the command line",
   "license": "MIT",
   "repository": {

package/runtime/include/js_buffer.h

@@ -10,7 +10,9 @@
 #include <stdint.h>
 #include <string.h>
 
+#include "js_convert.h"
 #include "js_object.h"
+#include "js_ops.h"
 
 #define JS_BUFFER_RESIZABLE 0x01u
 #define JS_BUFFER_DETACHED  0x02u
@@ -76,4 +78,187 @@ int js_typed_array_type(JSValue v);
 /* A new, zeroed Uint8Array of `length` bytes; its bytes are js_buffer_source_bytes'. */
 JS_WARN_UNUSED JSValue js_new_uint8_array(JSContext *ctx, size_t length);
 
+/* ---- Generated code: a typed array's elements inline ------------------------------------------ */
+
+/* The bytes of element i of a typed array generated code may read or write inline: a view of a
+ * fixed-size buffer (it can't shrink below the view, so i < length is in bounds), not detached,
+ * not immutable (for a write). NULL for anything else, which takes js_get_elem / js_set_elem. */
+static JS_FAST_PATH uint8_t *js_ta_inline_elem(JSContext *ctx, JSValue obj, int32_t i, bool write) {
+    if (!js_is_object(obj) || js_as_object(obj)->shape->cls != ctx->rt->typed_array_class) return NULL;
+    const JSTypedArray *ta = (const JSTypedArray *)js_as_object(obj);
+    const JSArrayBuffer *b = js_as_array_buffer(ta->buffer);
+    uint32_t bad = JS_BUFFER_DETACHED | JS_BUFFER_RESIZABLE | (write ? JS_BUFFER_IMMUTABLE : 0);
+    if (ta->length_tracking || i < 0 || (size_t)i >= ta->length || (b->flags & bad)) return NULL;
+    return b->data + ta->byte_offset;
+}
+
+/* obj[i]: a dense array's element or a typed array's (Int8, Uint8, Int32, Float64) inline. */
+static JS_FAST_PATH JSValue js_get_index_ta(JSContext *ctx, JSValue obj, JSValue key) {
+    if (JS_LIKELY(js_is_int32(key)) && !js_is_array(obj)) {
+        int32_t i = js_as_int32(key);
+        const uint8_t *p = js_ta_inline_elem(ctx, obj, i, false);
+        if (p) switch (((const JSTypedArray *)js_as_object(obj))->type) {
+            case JS_TA_UINT8: case JS_TA_UINT8C: return js_int32(p[i]);
+            case JS_TA_INT8: return js_int32((int8_t)p[i]);
+            case JS_TA_INT32: { int32_t v; memcpy(&v, p + 4 * (size_t)i, 4); return js_int32(v); }
+            case JS_TA_FLOAT64: { double v; memcpy(&v, p + 8 * (size_t)i, 8); return js_number(v); }
+            default: break;
+        }
+    }
+    return js_get_index(ctx, obj, key);
+}
+
+/* obj[i] = v: the same, for a Number v (no ToNumber code to run). */
+static JS_FAST_PATH int js_set_index_ta(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool strict) {
+    if (JS_LIKELY(js_is_int32(key)) && js_is_number(v) && !js_is_array(obj)) {
+        int32_t i = js_as_int32(key);
+        uint8_t *p = js_ta_inline_elem(ctx, obj, i, true);
+        if (p) switch (((const JSTypedArray *)js_as_object(obj))->type) {
+            case JS_TA_UINT8: case JS_TA_INT8: p[i] = (uint8_t)(js_is_int32(v) ? js_as_int32(v) : js_double_to_int32(js_as_number(v))); return 1;
+            case JS_TA_INT32: { int32_t x = js_is_int32(v) ? js_as_int32(v) : js_double_to_int32(js_as_number(v)); memcpy(p + 4 * (size_t)i, &x, 4); return 1; }
+            case JS_TA_FLOAT64: { double x = js_as_number(v); memcpy(p + 8 * (size_t)i, &x, 8); return 1; }
+            default: break;
+        }
+    }
+    return js_set_index(ctx, obj, key, v, strict);
+}
+
+/* The same with a double key (an unboxed index): an integral one is the int32 key (-0 too: "0"). */
+static inline JSValue js_get_index_ta_f64(JSContext *ctx, JSValue obj, double key) {
+    int32_t i = (int32_t)key;
+    if (key >= -2147483648.0 && key <= 2147483647.0 && (double)i == key) return js_get_index_ta(ctx, obj, js_int32(i));
+    return js_get_index_f64(ctx, obj, key);
+}
+static inline int js_set_index_ta_f64(JSContext *ctx, JSValue obj, double key, JSValue v, bool strict) {
+    int32_t i = (int32_t)key;
+    if (key >= -2147483648.0 && key <= 2147483647.0 && (double)i == key) return js_set_index_ta(ctx, obj, js_int32(i), v, strict);
+    return js_set_index_f64(ctx, obj, key, v, strict);
+}
+
+/* A typed array's elements as generated code holds them (the typed-arrays pass): taken once,
+ * for an array nothing else can reach, so nothing detaches or resizes its buffer. Empty (length
+ * 0) when the value isn't a typed array of that type: every access then takes the generic path. */
+typedef struct JSTAView {
+    uint8_t *base;
+    size_t   length;
+    int      type;   /* the element type it's for: a slow path that may have run code takes it again */
+} JSTAView;
+
+static inline JSTAView js_ta_view(JSContext *ctx, JSValue obj, int type) {
+    JSTAView v = { NULL, 0, type };
+    if (!js_is_object(obj) || js_as_object(obj)->shape->cls != ctx->rt->typed_array_class) return v;
+    const JSTypedArray *ta = (const JSTypedArray *)js_as_object(obj);
+    const JSArrayBuffer *b = js_as_array_buffer(ta->buffer);
+    if (ta->type != type || ta->length_tracking || (b->flags & (JS_BUFFER_DETACHED | JS_BUFFER_RESIZABLE | JS_BUFFER_IMMUTABLE)) || !b->data) return v;
+    v.base = b->data + ta->byte_offset;
+    v.length = ta->length;
+    return v;
+}
+
+/* Whether v is a typed array of that element type (a typed function's typed array parameter). */
+static inline bool js_ta_is(JSContext *ctx, JSValue v, int type) {
+    return js_is_object(v) && js_as_object(v)->shape->cls == ctx->rt->typed_array_class && ((const JSTypedArray *)js_as_object(v))->type == type;
+}
+
+/* The index a key names when it's in the view, else false. */
+static JS_FAST_PATH bool js_tav_index(const JSTAView *v, JSValue key, size_t *i) {
+    if (!js_is_int32(key) || js_as_int32(key) < 0 || (size_t)js_as_int32(key) >= v->length) return false;
+    *i = (size_t)js_as_int32(key);
+    return true;
+}
+static JS_FAST_PATH bool js_tav_index_d(const JSTAView *v, double key, size_t *i) {
+    if (!(key >= 0 && key < (double)v->length) || (double)(size_t)key != key) return false;
+    *i = (size_t)key;
+    return true;
+}
+
+/* Each element type's read and write (a Number, converted as the spec's NumericToRawBytes). */
+#define JS_TAV_ACCESS(name, ctype, box, unbox)                                                          \
+    static JS_FAST_PATH JSValue js_tav_get_##name(JSContext *ctx, JSTAView *v, JSValue obj, JSValue key) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(js_tav_index(v, key, &i))) { ctype x; memcpy(&x, v->base + i * sizeof x, sizeof x); return box(x); } \
+        JSValue r = js_get_elem(ctx, obj, key);                                                          \
+        *v = js_ta_view(ctx, obj, v->type);  /* a getter may have run */                                 \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH JSValue js_tav_get_##name##_d(JSContext *ctx, JSTAView *v, JSValue obj, double key) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(js_tav_index_d(v, key, &i))) { ctype x; memcpy(&x, v->base + i * sizeof x, sizeof x); return box(x); } \
+        JSValue r = js_get_elem(ctx, obj, js_number(key));                                               \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH JSValue js_tav_get_##name##_i(JSContext *ctx, JSTAView *v, JSValue obj, int32_t key) { \
+        if (JS_LIKELY((uint32_t)key < v->length)) { ctype x; memcpy(&x, v->base + (size_t)(uint32_t)key * sizeof x, sizeof x); return box(x); } \
+        JSValue r = js_get_elem(ctx, obj, js_int32(key));                                                \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_set_##name##_i(JSContext *ctx, JSTAView *v, JSValue obj, int32_t key, JSValue val, bool strict) { \
+        if (JS_LIKELY(js_is_number(val) && (uint32_t)key < v->length)) { ctype x = unbox(val); memcpy(v->base + (size_t)(uint32_t)key * sizeof x, &x, sizeof x); return 1; } \
+        int r = js_set_elem(ctx, obj, js_int32(key), val, strict);                                       \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH JSValue js_tav_get_##name##_l(JSContext *ctx, JSTAView *v, JSValue obj, int64_t key) { \
+        if (JS_LIKELY((uint64_t)key < v->length)) { ctype x; memcpy(&x, v->base + (size_t)key * sizeof x, sizeof x); return box(x); } \
+        JSValue r = js_get_elem(ctx, obj, js_number((double)key));                                       \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_set_##name##_l(JSContext *ctx, JSTAView *v, JSValue obj, int64_t key, JSValue val, bool strict) { \
+        if (JS_LIKELY(js_is_number(val) && (uint64_t)key < v->length)) { ctype x = unbox(val); memcpy(v->base + (size_t)key * sizeof x, &x, sizeof x); return 1; } \
+        int r = js_set_elem(ctx, obj, js_number((double)key), val, strict);                              \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_set_##name(JSContext *ctx, JSTAView *v, JSValue obj, JSValue key, JSValue val, bool strict) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(js_is_number(val) && js_tav_index(v, key, &i))) { ctype x = unbox(val); memcpy(v->base + i * sizeof x, &x, sizeof x); return 1; } \
+        int r = js_set_elem(ctx, obj, key, val, strict);  /* valueOf, a setter: they may have run */    \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_set_##name##_d(JSContext *ctx, JSTAView *v, JSValue obj, double key, JSValue val, bool strict) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(js_is_number(val) && js_tav_index_d(v, key, &i))) { ctype x = unbox(val); memcpy(v->base + i * sizeof x, &x, sizeof x); return 1; } \
+        int r = js_set_elem(ctx, obj, js_number(key), val, strict);                                      \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }
+static JS_FAST_PATH int32_t js_tav_to_int32(JSValue v) { return js_is_int32(v) ? js_as_int32(v) : js_double_to_int32(js_as_number(v)); }
+#define JS_TAV_INT(x) js_int32((int32_t)(x))
+JS_TAV_ACCESS(i8, int8_t, JS_TAV_INT, (int8_t)js_tav_to_int32)
+JS_TAV_ACCESS(u8, uint8_t, JS_TAV_INT, (uint8_t)js_tav_to_int32)
+JS_TAV_ACCESS(i32, int32_t, JS_TAV_INT, js_tav_to_int32)
+JS_TAV_ACCESS(f64, double, js_number, js_as_number)
+
+/* A Float64Array's element as a double, for typed code ("use static": its type is number):
+ * past the end, undefined as a number (NaN). False with an exception pending. And a store of a
+ * double, boxed only on the slow path. */
+static inline bool js_tav_num_slow(JSContext *ctx, JSTAView *v, JSValue obj, JSValue key, double *out) {
+    JSValue r = js_get_elem(ctx, obj, key);
+    *v = js_ta_view(ctx, obj, v->type);
+    if (js_is_exception(r)) return false;
+    if (js_is_number(r)) { *out = js_as_number(r); return true; }
+    return js_to_number(ctx, out, r) == 0;
+}
+#define JS_TAV_F64(suffix, ktype, in_view, boxed_key)                                                   \
+    static JS_FAST_PATH bool js_tav_num_f64##suffix(JSContext *ctx, JSTAView *v, JSValue obj, ktype key, double *out) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(in_view)) { memcpy(out, v->base + i * 8, 8); return true; }                        \
+        return js_tav_num_slow(ctx, v, obj, boxed_key, out);                                            \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_put_f64##suffix(JSContext *ctx, JSTAView *v, JSValue obj, ktype key, double x, bool strict) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(in_view)) { memcpy(v->base + i * 8, &x, 8); return 1; }                            \
+        int r = js_set_elem(ctx, obj, boxed_key, js_number(x), strict);                                  \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }
+JS_TAV_F64(, JSValue, js_tav_index(v, key, &i), key)
+JS_TAV_F64(_d, double, js_tav_index_d(v, key, &i), js_number(key))
+JS_TAV_F64(_i, int32_t, ((i = (size_t)(uint32_t)key) < v->length), js_int32(key))
+JS_TAV_F64(_l, int64_t, ((i = (size_t)(uint64_t)key) < v->length), js_number((double)key))
+
 #endif /* JS_BUFFER_H */

package/runtime/include/js_builtins.h

@@ -211,7 +211,65 @@ static inline JSValue js_call_char_code_at(JSContext *ctx, JSValue f, JSValue s,
     return js_call_site(ctx, f, s, 1, &i, site);
 }
 
+/* s.charCodeAt(i) in typed code ("use static"), which trusts the built-ins to be the standard
+ * ones (char_code_at): s is a string; its unit read inline, else (a rope, an index out of
+ * range) the built-in's answer. */
+static inline double js_string_char_code_at(JSContext *ctx, JSValue s, double i) {
+    JSStrView v;
+    if (JS_LIKELY(i >= 0 && i < 4294967295.0 && js_string_units(s, &v) && (uint32_t)i < v.length && (double)(uint32_t)i == i))
+        return (double)js_view_at(v, (uint32_t)i);
+    JSValue index = js_number(i);
+    return js_as_number(js_core_string_proto_char_code_at(ctx, JS_UNDEFINED, s, 1, &index, JS_UNDEFINED));
+}
+
+/* s.charCodeAt(i) in typed code for an index the optimizer proved in s: the unit, an int32 (a
+ * rope not yet flattened takes the built-in). */
+static inline int32_t js_string_unit_at(JSContext *ctx, JSValue s, uint32_t i) {
+    JSStrView v;
+    if (JS_LIKELY(js_string_units(s, &v))) return (int32_t)js_view_at(v, i);
+    return (int32_t)js_string_char_code_at(ctx, s, (double)i);
+}
+
+/* Function.prototype.apply and call: generated code tells them by their entry. */
+JSValue js_function_proto_apply(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_function_proto_call(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* f.apply(t, args), `m` the value of f.apply: when m is the built-in and f callable, f is called
+ * without the built-in in between, with a short dense array's elements copied to the stack (its
+ * elements are its own data properties: reading them runs no code; copied, as f may change the
+ * array). Anything else is the call of m. */
+static inline JSValue js_call_apply(JSContext *ctx, JSValue m, JSValue f, JSValue t, JSValue args, const char *site) {
+    if (JS_LIKELY(js_is_function(m) && js_as_function(m)->entry == js_function_proto_apply && js_is_callable(f))) {
+        if (js_is_nullish(args)) return js_call(ctx, f, t, 0, NULL);
+        if (js_is_array(args)) {
+            JSObject *a = js_as_object(args);
+            JSElements *e = a->elements;
+            uint32_t n = js_array_length(a);
+            JSValue copy[8];
+            if (e->kind == JS_ELEMENTS_DENSE && e->length == n && n <= 8) {
+                uint32_t i = 0;
+                while (i < n && !js_is_empty(e->data[i])) copy[i] = e->data[i], i++;
+                if (i == n) return js_call(ctx, f, t, n, copy);
+            }
+        }
+    }
+    return js_call_site(ctx, m, f, 2, (const JSValue[]){ t, args }, site);
+}
+
+/* f.call(t, …), `m` the value of f.call: f called directly when m is the built-in and f callable.
+ * argv: t, then the arguments. */
+static inline JSValue js_call_call(JSContext *ctx, JSValue m, JSValue f, uint32_t argc, const JSValue *argv, const char *site) {
+    if (JS_LIKELY(js_is_function(m) && js_as_function(m)->entry == js_function_proto_call && js_is_callable(f)))
+        return js_call(ctx, f, argc ? argv[0] : JS_UNDEFINED, argc ? argc - 1 : 0, argc ? argv + 1 : NULL);
+    return js_call_site(ctx, m, f, argc, argv, site);
+}
+
 /* String.fromCharCode(c): a unit up to 0xFF is a static one-unit string. */
+/* Static code's String.fromCharCode(c), trusted to be the built-in: c's unit (ToUint16). */
+static inline JSValue js_from_char_code_unit(JSContext *ctx, uint16_t unit) {
+    return unit <= 0xFF ? js_char_string((uint8_t)unit) : js_new_string_utf16(ctx, &unit, 1);
+}
+
 static inline JSValue js_call_from_char_code(JSContext *ctx, JSValue f, JSValue this_val, JSValue c, const char *site) {
     if (JS_LIKELY(js_is_function(f) && js_as_function(f)->entry == js_core_string_from_char_code && js_is_int32(c)
                   && (uint32_t)js_as_int32(c) <= 0xFF))

package/runtime/include/js_crypto.h

@@ -64,6 +64,11 @@ JS_CRYPTO_PRIMITIVE(js_tls_context_add_roots)
 JS_CRYPTO_PRIMITIVE(js_tls_context_add_ca)
 JS_CRYPTO_PRIMITIVE(js_tls_context_set_cert)
 JS_CRYPTO_PRIMITIVE(js_tls_context_set_key)
+JS_CRYPTO_PRIMITIVE(js_tls_context_add_credential)
+JS_CRYPTO_PRIMITIVE(js_tls_context_allow_partial_chain)
+JS_CRYPTO_PRIMITIVE(js_tls_context_ticket_keys)
+JS_CRYPTO_PRIMITIVE(js_tls_context_set_sessions)
+JS_CRYPTO_PRIMITIVE(js_tls_pkcs12)
 JS_CRYPTO_PRIMITIVE(js_tls_root_certificates)
 JS_CRYPTO_PRIMITIVE(js_tls_new)
 JS_CRYPTO_PRIMITIVE(js_tls_run)
@@ -72,10 +77,16 @@ JS_CRYPTO_PRIMITIVE(js_tls_info)
 JS_CRYPTO_PRIMITIVE(js_tls_peer_certs)
 JS_CRYPTO_PRIMITIVE(js_tls_verify_error)
 JS_CRYPTO_PRIMITIVE(js_tls_session)
+JS_CRYPTO_PRIMITIVE(js_tls_ticket)
 JS_CRYPTO_PRIMITIVE(js_tls_export_keying_material)
 JS_CRYPTO_PRIMITIVE(js_tls_set_no_renegotiation)
+JS_CRYPTO_PRIMITIVE(js_tls_enable_keylog)
+JS_CRYPTO_PRIMITIVE(js_tls_set_max_send_fragment)
 JS_CRYPTO_PRIMITIVE(js_tls_finished)
 JS_CRYPTO_PRIMITIVE(js_tls_ciphers)
+JS_CRYPTO_PRIMITIVE(js_x509_check)
+JS_CRYPTO_PRIMITIVE(js_x509_check_issued)
+JS_CRYPTO_PRIMITIVE(js_x509_check_key)
 #undef JS_CRYPTO_PRIMITIVE
 
 #endif /* JS_CRYPTO_H */

package/runtime/include/js_exception.h

@@ -28,6 +28,9 @@ JS_WARN_UNUSED JSValue js_throw_reference_error(JSContext *ctx, const char *fmt,
 JS_WARN_UNUSED JSValue js_throw_syntax_error(JSContext *ctx, const char *fmt, ...);
 JS_WARN_UNUSED JSValue js_throw_uri_error(JSContext *ctx, const char *fmt, ...);
 JS_WARN_UNUSED JSValue js_throw_stack_overflow(JSContext *ctx);  /* RangeError: Maximum call stack size exceeded */
+/* ERR_INVALID_ARG_TYPE: `The "dest" argument must be <expected>. Received …` (Node's wording
+ * of the value). Generated code calls it: a "use static" function's checked entry. */
+JS_WARN_UNUSED JSValue js_throw_invalid_arg_type(JSContext *ctx, const char *name, const char *expected, JSValue value);
 
 /* ---- Catching ---------------------------------------------------------- */
 

package/runtime/include/js_function.h

@@ -79,7 +79,7 @@ typedef struct JSFunction {       /* kind = FUNCTION */
     JSContext             *realm;        /* the realm the function was created in */
     uint32_t               flags;
     uint32_t               pad_;
-    struct JSShape        *instance_shape;  /* a class's instances' root shape, made at its first `new` (js_new_class_instance) */
+    struct JSShape        *instance_shape;  /* the root shape of the objects `new` makes with it as new.target: inline slots for all their constructors add */
 } JSFunction;
 
 extern const JSClass js_class_function;