visaljs 0.0.10 → 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.10",
+  "version": "0.0.11",
   "description": "Ahead-of-time JavaScript to C compiler: the command line",
   "license": "MIT",
   "repository": {

package/runtime/include/js_builtins.h

@@ -265,6 +265,11 @@ static inline JSValue js_call_call(JSContext *ctx, JSValue m, JSValue f, uint32_
 }
 
 /* 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_gc.h

@@ -50,24 +50,27 @@ typedef struct JSBlock {
     size_t   map_size;           /* JS_BLOCK_SIZE, or the large object's mapping */
     uint32_t cell_size;
     uint32_t cell_count;
-    uint8_t  size_class;
+    uint8_t  size_class;         /* a small block's */
     uint8_t  is_large;
-    union {
-        uint8_t queued;          /* in its class's sweep queue */
-        uint8_t remembered;      /* a large object: in the remembered set, with cards marked */
-    };
+    uint8_t  queued;             /* in its class's sweep queue */
     uint8_t  has_finalizable;
     uint32_t index_magic;        /* ceil(2^32 / cell_size): a cell's index is (offset * magic) >> 32 */
     uint8_t  young;              /* the allocator took it since the last collection */
+    uint8_t  remembered;         /* a large object: in the remembered set, with cards marked */
+    uint8_t  card_shift;         /* a large object: a card is 2^card_shift bytes of it */
     uint64_t mark_bits[JS_BITMAP_WORDS];
-    uint64_t alloc_bits[JS_BITMAP_WORDS];  /* exact only while the world is stopped */
+    union {
+        uint64_t alloc_bits[JS_BITMAP_WORDS];  /* exact only while the world is stopped */
+        /* A large object's: its one cell's allocation bit, then its cards, a bit per card that a
+         * store gave a young cell since the last collection. */
+        struct {
+            uint64_t large_alloc;
+            uint64_t cards[JS_BITMAP_WORDS - 1];
+        };
+    };
 } JSBlock;
 
-/* A large object's cards: a bit per 2^card_shift bytes of the object
- * that a store gave a young cell since the last collection. They live in the allocation bitmap,
- * whose only other bit is bit 0 of word 0. A large object's size_class is its card_shift. */
 #define JS_LARGE_CARDS ((JS_BITMAP_WORDS - 1) * 64)
-static inline uint64_t *js_large_cards(JSBlock *b) { return &b->alloc_bits[1]; }
 
 #define JS_BLOCK_FIRST_CELL \
     ((sizeof(JSBlock) + JS_CELL_ALIGN - 1) & ~(size_t)(JS_CELL_ALIGN - 1))

package/runtime/include/js_jobs.h

@@ -65,6 +65,8 @@ typedef enum JSRejectionMode {
 } JSRejectionMode;
 
 void js_enqueue_microtask(JSContext *ctx, const JSJob *job);
+/* process.nextTick's queue, which a checkpoint runs before the microtasks (Node's order) */
+void js_enqueue_tick(JSContext *ctx, const JSJob *job);
 /* The checkpoint: runs every queued job (and the ones they queue), then processes
  * unhandled rejections. A nested call does nothing. 0, or -1 after an uncaught error
  * or a strict unhandled rejection (already reported). */

package/runtime/include/js_object.h

@@ -493,6 +493,64 @@ static inline JSValue js_get_length(JSContext *ctx, JSValue obj, JSValue key, JS
     if (js_is_string(obj)) return js_int32((int32_t)js_string_length(obj));  /* below 2^30 */
     return js_get_prop(ctx, obj, key, ic);
 }
+/* ---- Static code's arrays ("use static": number[], string[], boolean[]) ------------------ */
+
+/* An element's kind (an i32[] is a number[] whose reads the code converts). tsc's element types
+ * aren't sound (a cast, an i32[] alias of a number[]), so every read checks it: a read's value is
+ * of the kind or the read throws. An index past the end is a RangeError, never undefined or a hole. */
+enum { JS_SARRAY_NUMBER, JS_SARRAY_STRING, JS_SARRAY_BOOLEAN };
+
+static inline bool js_sarray_is(JSValue v, int kind) {
+    switch (kind) {
+        case JS_SARRAY_NUMBER: return js_is_number(v);
+        case JS_SARRAY_STRING: return !js_is_empty(v) && js_is_string(v);
+        default: return js_is_bool(v);
+    }
+}
+/* A Number key as an index: -1 (past every end) when it isn't one. */
+static inline int64_t js_sarray_index_f64(double key) {
+    return key >= 0 && key < 4294967295.0 && (double)(int64_t)key == key ? (int64_t)key : -1;
+}
+static inline int64_t js_sarray_index(JSValue key) {
+    return js_is_int32(key) ? js_as_int32(key) : js_sarray_index_f64(js_as_number(key));
+}
+JS_WARN_UNUSED JSValue js_sarray_get_slow(JSContext *ctx, JSValue arr, int64_t i, int kind);
+JS_WARN_UNUSED int js_sarray_set_slow(JSContext *ctx, JSValue arr, int64_t i, JSValue v, int kind);
+JS_WARN_UNUSED JSValue js_sarray_length_slow(JSContext *ctx, JSValue arr);
+JS_WARN_UNUSED JSValue js_sarray_push_slow(JSContext *ctx, JSValue arr, JSValue v, int kind);
+
+static JS_FAST_PATH JSValue js_sarray_get(JSContext *ctx, JSValue arr, int64_t i, int kind) {
+    if (JS_LIKELY(js_is_array(arr))) {
+        JSElements *d = js_as_object(arr)->elements;
+        if (JS_LIKELY(d->kind == JS_ELEMENTS_DENSE && (uint64_t)i < d->length && js_sarray_is(d->data[i], kind))) return d->data[i];
+    }
+    return js_sarray_get_slow(ctx, arr, i, kind);
+}
+/* a[i] = v: at the length, a push; past it, a RangeError. */
+static JS_FAST_PATH int js_sarray_set(JSContext *ctx, JSValue arr, int64_t i, JSValue v, int kind) {
+    if (JS_LIKELY(js_is_array(arr) && js_sarray_is(v, kind))) {
+        JSElements *d = js_as_object(arr)->elements;
+        if (JS_LIKELY(d->kind == JS_ELEMENTS_DENSE && (uint64_t)i < d->length && !js_is_empty(d->data[i]))) {
+            js_store(ctx, &d->cell, &d->data[i], v);
+            return 1;
+        }
+    }
+    return js_sarray_set_slow(ctx, arr, i, v, kind);
+}
+/* a.length, an int32 (a longer array is a RangeError). */
+static JS_FAST_PATH JSValue js_sarray_length(JSContext *ctx, JSValue arr) {
+    if (JS_LIKELY(js_is_array(arr) && js_array_length(js_as_object(arr)) <= INT32_MAX)) return js_int32((int32_t)js_array_length(js_as_object(arr)));
+    return js_sarray_length_slow(ctx, arr);
+}
+/* a.push(v): the new length, an int32. */
+static JS_FAST_PATH JSValue js_sarray_push(JSContext *ctx, JSValue arr, JSValue v, int kind) {
+    if (JS_LIKELY(js_is_array(arr) && js_sarray_is(v, kind) && js_array_length(js_as_object(arr)) < INT32_MAX)) {
+        if (JS_UNLIKELY(js_array_push(ctx, js_as_object(arr), v) < 0)) return JS_EXCEPTION;
+        return js_int32((int32_t)js_array_length(js_as_object(arr)));
+    }
+    return js_sarray_push_slow(ctx, arr, v, kind);
+}
+
 /* delete obj[key]: true or false (sloppy), a TypeError when strict and not deletable.
  * `key` is a property key; js_delete_elem converts it first. */
 JS_WARN_UNUSED JSValue js_delete_value(JSContext *ctx, JSValue obj, JSValue key, bool strict);

package/runtime/include/jscontext.h

@@ -189,6 +189,7 @@ struct JSRuntime {
     JSValue   symbol_registry;  /* Symbol.for's GlobalSymbolRegistry: key -> symbol (a root) */
     uintptr_t stack_limit;  /* lowest usable stack address, margin included */
     JSJobQueue jobs;        /* microtasks */
+    JSJobQueue ticks;       /* process.nextTick's: each checkpoint runs them all before the microtasks (Node's) */
     JSTimers  timers;       /* setTimeout / setInterval */
     /* The async context: an opaque value the host keeps per chain of async work
      * (node:async_hooks' AsyncLocalStorage keeps its stores in it). Every job, timer and promise

package/runtime/src/crypto_internal.h

@@ -267,6 +267,7 @@ const char *js_ec_curve_jwk(int curve);
 typedef enum JSWebAlg {
     JS_WEB_HMAC = 1, JS_WEB_PBKDF2, JS_WEB_HKDF, JS_WEB_AES_CTR, JS_WEB_AES_CBC, JS_WEB_AES_GCM, JS_WEB_AES_KW,
     JS_WEB_RSASSA, JS_WEB_RSA_PSS, JS_WEB_RSA_OAEP, JS_WEB_ECDSA, JS_WEB_ECDH, JS_WEB_X25519, JS_WEB_ED25519,
+    JS_WEB_CHACHA20_POLY1305,
 } JSWebAlg;
 
 /* KeyUsage, as bits in this order */