quickjs 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5796bac189dd080cf33b19413b16f01aa38a432de8cc70a102d6215e3aa6788a
-  data.tar.gz: ff57fa394865f9f2e5881a0e8953662644e51f76aecff2e1cddb16d9f42edc4e
+  metadata.gz: 69b86d7c5040dba161c1d6f67cb3eab3fd8a3dc51b30eb6d355c2580dbc29602
+  data.tar.gz: 5e174baed18d79e0ac18a496f97cd580fd20830a98fb240351eeea46abe57683
 SHA512:
-  metadata.gz: df8c07bb183fdfa7c6440198fcfe24a158cc6cde23fd645dbcaf8bd2c2642c4855e4e09ac459761b4272cbc0332ff7e32856ceb8e5fdb844390b3db37194f7e0
-  data.tar.gz: 797fd273ee7888ee2fd6066b2fff620b8b8b13ca33f0f18f0a7b1c24d0a0df980991b22aac1387cf94a08f8dedc0c81ad6a408e9e60ad81f6dc37a59205a2ba2
+  metadata.gz: 9f7abcc1733fcfe9c51aacf81c9e34b05e7e44142a9db79a8bd4525ba67570f897cd7c1fb200428507876dad35a67b9a3f383711a3b0cfc9ff1b46728cd1c125
+  data.tar.gz: a15abae6b482f0df7efc89e9b0a3b9d3ca3bab8bb8d04ce7844f60b195a0314d8e12d2b3bbdf8cf01dae763e75945d4e84cf3c1efbe2a99d4cfa525e2279625e

data/README.md

@@ -61,6 +61,8 @@ Quickjs.eval_code(code, features: [::Quickjs::MODULE_STD, ::Quickjs::POLYFILL_FI
 | `POLYFILL_INTL` | Intl API (DateTimeFormat, NumberFormat, PluralRules, Locale) |
 | `POLYFILL_FILE` | W3C File API (Blob and File) |
 | `POLYFILL_ENCODING` | Encoding API (TextEncoder and TextDecoder) |
+| `POLYFILL_URL` | URL API (URL and URLSearchParams) |
+| `POLYFILL_CRYPTO` | Web Crypto API (`crypto.getRandomValues`, `crypto.randomUUID`, `crypto.subtle`); combine with `POLYFILL_ENCODING` for string↔buffer conversion |
 
 </details>
 
@@ -76,6 +78,29 @@ vm.eval_code('a.b = "d";')
 vm.eval_code('a.b;') #=> "d"
 ```
 
+#### `Quickjs::VM#call`: ⚡ Call a JS function directly with Ruby arguments
+
+```rb
+vm = Quickjs::VM.new
+vm.eval_code('function add(a, b) { return a + b; }')
+
+vm.call('add', 1, 2)           #=> 3
+vm.call(:add, 1, 2)            #=> 3  (Symbol also works)
+
+# Nested functions — preserves `this` binding
+vm.eval_code('const counter = { n: 0, inc() { return ++this.n; } }')
+vm.call('counter.inc')         #=> 1
+vm.call('counter.inc')         #=> 2
+
+# Keys with special characters via bracket notation
+vm.eval_code("const obj = {}; obj['my-fn'] = x => x * 2;")
+vm.call('obj["my-fn"]', 21)    #=> 42
+
+# Async functions are automatically awaited
+vm.eval_code('async function fetchVal() { return 42; }')
+vm.call('fetchVal')            #=> 42
+```
+
 #### `Quickjs::VM#import`: 🔌 Import ESM from a source code
 
 ```rb
@@ -165,13 +190,18 @@ vm.eval_code('console.log("hello", 42)')
 - `ext/quickjsrb/quickjs`
   - [MIT License Copyright (c) 2017-2021 by Fabrice Bellard and Charlie Gordon](https://github.com/bellard/quickjs/blob/6e2e68fd0896957f92eb6c242a2e048c1ef3cae0/LICENSE).
 - `ext/quickjsrb/vendor/polyfill-intl-en.min.js` ([bundled and minified from `polyfills/`](https://github.com/hmsk/quickjs.rb/tree/main/polyfills))
+  - MIT License Copyright (c) 2022 FormatJS
+    - [@formatjs/intl-supportedvaluesof](https://github.com/formatjs/formatjs/blob/main/packages/intl-supportedvaluesof/LICENSE.md)
   - MIT License Copyright (c) 2023 FormatJS
     - [@formatjs/intl-getcanonicallocales](https://github.com/formatjs/formatjs/blob/main/packages/intl-getcanonicallocales/LICENSE.md)
     - [@formatjs/intl-locale](https://github.com/formatjs/formatjs/blob/main/packages/intl-locale/LICENSE.md)
     - [@formatjs/intl-pluralrules](https://github.com/formatjs/formatjs/blob/main/packages/intl-pluralrules/LICENSE.md)
     - [@formatjs/intl-numberformat](https://github.com/formatjs/formatjs/blob/main/packages/intl-numberformat/LICENSE.md)
     - [@formatjs/intl-datetimeformat](https://github.com/formatjs/formatjs/blob/main/packages/intl-datetimeformat/LICENSE.md)
-  - MIT License Copyright (c) 2025 Michael Mclaughlin
-    - [decimal.js](https://www.npmjs.com/package/decimal.js)
+    - [@formatjs/ecma402-abstract](https://github.com/formatjs/formatjs/blob/main/packages/ecma402-abstract/LICENSE.md)
+    - [@formatjs/fast-memoize](https://github.com/formatjs/formatjs/blob/main/packages/fast-memoize/LICENSE.md)
+    - [@formatjs/intl-localematcher](https://github.com/formatjs/formatjs/blob/main/packages/intl-localematcher/LICENSE.md)
+  - MIT License Copyright (c) 2026 FormatJS
+    - [@formatjs/bigdecimal](https://github.com/formatjs/formatjs/blob/main/packages/bigdecimal/LICENSE.md)
 
 Otherwise, [the MIT License, Copyright 2024 by Kengo Hamasaki](/LICENSE).

data/Rakefile

@@ -54,6 +54,13 @@ namespace :polyfills do
     Rake::Task[:compile].invoke
   end
 
+  desc 'Check licenses of bundled polyfill dependencies'
+  task :check_licenses do
+    Dir.chdir(File.expand_path('polyfills', __dir__)) do
+      sh 'npm run check-licenses'
+    end
+  end
+
   namespace :version do
     task :check do
       check_polyfill_version! do |pkg_v, gem_v|

data/ext/quickjsrb/extconf.rb

@@ -14,8 +14,11 @@ $srcs = [
   'polyfill-intl-en.min.c',
   'polyfill-file.min.c',
   'polyfill-encoding.min.c',
+  'polyfill-url.min.c',
   'quickjsrb.c',
   'quickjsrb_file.c',
+  'quickjsrb_crypto.c',
+  'quickjsrb_crypto_subtle.c',
 ]
 
 append_cflags('-I$(srcdir)/quickjs')
@@ -72,6 +75,10 @@ polyfill-encoding.min.js:
 		$(COPY) $(srcdir)/vendor/$@ $@
 polyfill-encoding.min.c: ./qjsc polyfill-encoding.min.js
 		./qjsc -fno-string-normalize -fno-eval -fno-proxy -fno-module-loader -c -M polyfill/encoding.so,encoding -m -o $@ polyfill-encoding.min.js
+polyfill-url.min.js:
+		$(COPY) $(srcdir)/vendor/$@ $@
+polyfill-url.min.c: ./qjsc polyfill-url.min.js
+		./qjsc -fno-string-normalize -fno-eval -fno-proxy -fno-module-loader -c -M polyfill/url.so,url -m -o $@ polyfill-url.min.js
 COMPILE_POLYFILL
   conf
 end

data/ext/quickjsrb/quickjsrb.c

@@ -1,5 +1,6 @@
 #include "quickjsrb.h"
 #include "quickjsrb_file.h"
+#include "quickjsrb_crypto.h"
 
 const char *featureStdId = "feature_std";
 const char *featureOsId = "feature_os";
@@ -7,6 +8,8 @@ const char *featureTimeoutId = "feature_timeout";
 const char *featurePolyfillIntlId = "feature_polyfill_intl";
 const char *featurePolyfillFileId = "feature_polyfill_file";
 const char *featurePolyfillEncodingId = "feature_polyfill_encoding";
+const char *featurePolyfillUrlId = "feature_polyfill_url";
+const char *featurePolyfillCryptoId = "feature_polyfill_crypto";
 
 const char *undefinedId = "undefined";
 const char *nanId = "NaN";
@@ -486,20 +489,14 @@ static VALUE r_try_call_listener(VALUE r_args)
 
 static int dispatch_log(VMData *data, const char *severity, VALUE r_row)
 {
+  if (NIL_P(data->log_listener))
+    return 0;
+
   VALUE r_log = r_log_new(severity, r_row);
-  if (!NIL_P(data->log_listener))
-  {
-    VALUE r_args = rb_ary_new3(2, data->log_listener, r_log);
-    int error;
-    rb_protect(r_try_call_listener, r_args, &error);
-    if (error)
-      return error;
-  }
-  else
-  {
-    rb_ary_push(data->logs, r_log);
-  }
-  return 0;
+  VALUE r_args = rb_ary_new3(2, data->log_listener, r_log);
+  int error;
+  rb_protect(r_try_call_listener, r_args, &error);
+  return error;
 }
 
 static VALUE vm_m_on_log(VALUE r_self)
@@ -680,6 +677,18 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
     JS_FreeValue(data->context, j_polyfillEncodingResult);
   }
 
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featurePolyfillUrlId))))
+  {
+    JSValue j_polyfillUrlObject = JS_ReadObject(data->context, &qjsc_polyfill_url_min, qjsc_polyfill_url_min_size, JS_READ_OBJ_BYTECODE);
+    JSValue j_polyfillUrlResult = JS_EvalFunction(data->context, j_polyfillUrlObject);
+    JS_FreeValue(data->context, j_polyfillUrlResult);
+  }
+
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featurePolyfillCryptoId))))
+  {
+    quickjsrb_init_crypto(data->context, j_global);
+  }
+
   JSValue j_console = JS_NewObject(data->context);
   JS_SetPropertyStr(
       data->context, j_console, "log",
@@ -713,6 +722,20 @@ static int interrupt_handler(JSRuntime *runtime, void *opaque)
   return elapsed_ms >= eval_time->limit_ms ? 1 : 0;
 }
 
+static VALUE to_rb_return_value(JSContext *ctx, JSValue j_val)
+{
+  if (JS_VALUE_GET_NORM_TAG(j_val) == JS_TAG_OBJECT && JS_PromiseState(ctx, j_val) != -1)
+  {
+    JS_FreeValue(ctx, j_val);
+    VALUE r_error_message = rb_str_new2("An unawaited Promise was returned to the top-level");
+    rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_NO_AWAIT_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
+    return Qnil;
+  }
+  VALUE result = to_rb_value(ctx, j_val);
+  JS_FreeValue(ctx, j_val);
+  return result;
+}
+
 static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
 {
   VMData *data;
@@ -730,26 +753,11 @@ static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
   char *code = StringValueCStr(r_code);
   JSValue j_codeResult = JS_Eval(data->context, code, strlen(code), "<code>", JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_ASYNC);
   JSValue j_awaitedResult = js_std_await(data->context, j_codeResult); // This frees j_codeResult
+  // JS_EVAL_FLAG_ASYNC wraps the result in {value, done} — extract the actual value
+  // Free j_awaitedResult before to_rb_return_value because it may raise (longjmp), which would skip cleanup
   JSValue j_returnedValue = JS_GetPropertyStr(data->context, j_awaitedResult, "value");
-  // Do this by rescuing to_rb_value
-  if (JS_VALUE_GET_NORM_TAG(j_returnedValue) == JS_TAG_OBJECT && JS_PromiseState(data->context, j_returnedValue) != -1)
-  {
-    JS_FreeValue(data->context, j_returnedValue);
-    JS_FreeValue(data->context, j_awaitedResult);
-    VALUE r_error_message = rb_str_new2("An unawaited Promise was returned to the top-level");
-    rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_NO_AWAIT_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
-    return Qnil;
-  }
-  else
-  {
-    // Free j_awaitedResult before to_rb_value because to_rb_value may
-    // raise (longjmp) for JS exceptions, which would skip any cleanup
-    // after it and leak JS GC objects.
-    JS_FreeValue(data->context, j_awaitedResult);
-    VALUE result = to_rb_value(data->context, j_returnedValue);
-    JS_FreeValue(data->context, j_returnedValue);
-    return result;
-  }
+  JS_FreeValue(data->context, j_awaitedResult);
+  return to_rb_return_value(data->context, j_returnedValue);
 }
 
 static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
@@ -790,6 +798,142 @@ static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
   return r_name_sym;
 }
 
+static VALUE vm_m_callGlobalFunction(int argc, VALUE *argv, VALUE r_self)
+{
+  if (argc < 1)
+    rb_raise(rb_eArgError, "wrong number of arguments (given 0, expected 1+)");
+
+  VALUE r_name = argv[0];
+
+  VMData *data;
+  TypedData_Get_Struct(r_self, VMData, &vm_type, data);
+
+  JSValue j_this = JS_UNDEFINED;
+  JSValue j_func;
+
+  VALUE r_path;
+  if (SYMBOL_P(r_name) || RB_TYPE_P(r_name, T_STRING))
+  {
+    VALUE r_name_str = rb_funcall(r_name, rb_intern("to_s"), 0);
+    const char *name_str = StringValueCStr(r_name_str);
+    size_t name_len = strlen(name_str);
+    const char *last_bracket = strrchr(name_str, '[');
+    const char *last_dot = strrchr(name_str, '.');
+
+    if (last_bracket != NULL && last_bracket != name_str && name_str[name_len - 1] == ']')
+    {
+      // Bracket notation: 'a["key"]' or 'a.b["key"]' or 'a[0]'
+      // Split into parent expression and the bracketed key
+      VALUE r_parent = rb_str_new(name_str, last_bracket - name_str);
+      const char *key_start = last_bracket + 1;
+      size_t key_len = name_len - (key_start - name_str) - 1; // exclude ']'
+      // Strip surrounding quotes for string keys: 'a["b"]' → key = b
+      if (key_len >= 2 &&
+          ((key_start[0] == '\'' && key_start[key_len - 1] == '\'') ||
+           (key_start[0] == '"' && key_start[key_len - 1] == '"')))
+      {
+        key_start++;
+        key_len -= 2;
+      }
+      VALUE r_key = rb_str_new(key_start, key_len);
+      r_path = rb_ary_new3(2, r_parent, r_key);
+    }
+    else if (last_dot != NULL && last_dot != name_str)
+    {
+      // Dot notation: 'a.b.c' → ['a.b', 'c'] so the parent becomes `this`
+      VALUE r_parent = rb_str_new(name_str, last_dot - name_str);
+      VALUE r_key = rb_str_new2(last_dot + 1);
+      r_path = rb_ary_new3(2, r_parent, r_key);
+    }
+    else
+    {
+      r_path = rb_ary_new3(1, r_name_str);
+    }
+  }
+  else
+  {
+    rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
+  }
+
+  {
+    long path_len = RARRAY_LEN(r_path);
+
+    VALUE r_first = RARRAY_AREF(r_path, 0);
+    if (!(SYMBOL_P(r_first) || RB_TYPE_P(r_first, T_STRING)))
+      rb_raise(rb_eTypeError, "function path elements should be Symbols or Strings");
+
+    VALUE r_first_str = rb_funcall(r_first, rb_intern("to_s"), 0);
+    const char *first_seg = StringValueCStr(r_first_str);
+
+    // JS_Eval accesses both global object properties and lexical (const/let) bindings
+    JSValue j_cur = JS_Eval(data->context, first_seg, strlen(first_seg), "<vm>", JS_EVAL_TYPE_GLOBAL);
+    if (JS_IsException(j_cur))
+      return to_rb_value(data->context, j_cur); // raises
+
+    for (long i = 1; i < path_len; i++)
+    {
+      VALUE r_seg = RARRAY_AREF(r_path, i);
+      if (!(SYMBOL_P(r_seg) || RB_TYPE_P(r_seg, T_STRING)))
+      {
+        JS_FreeValue(data->context, j_cur);
+        JS_FreeValue(data->context, j_this);
+        rb_raise(rb_eTypeError, "function path elements should be Symbols or Strings");
+      }
+      VALUE r_seg_str = rb_funcall(r_seg, rb_intern("to_s"), 0);
+      const char *seg = StringValueCStr(r_seg_str);
+
+      JSValue j_next = JS_GetPropertyStr(data->context, j_cur, seg);
+      if (JS_IsException(j_next))
+      {
+        JS_FreeValue(data->context, j_cur);
+        JS_FreeValue(data->context, j_this);
+        return to_rb_value(data->context, j_next); // raises
+      }
+
+      JS_FreeValue(data->context, j_this);
+      j_this = j_cur;
+      j_cur = j_next;
+    }
+
+    j_func = j_cur;
+  }
+
+  if (!JS_IsFunction(data->context, j_func))
+  {
+    JS_FreeValue(data->context, j_func);
+    JS_FreeValue(data->context, j_this);
+    VALUE r_error_message = rb_str_new2("given path is not a function");
+    rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
+    return Qnil;
+  }
+
+  int nargs = argc - 1;
+  JSValue *j_args = NULL;
+  if (nargs > 0)
+  {
+    j_args = (JSValue *)malloc(sizeof(JSValue) * nargs);
+    for (int i = 0; i < nargs; i++)
+      j_args[i] = to_js_value(data->context, argv[i + 1]);
+  }
+
+  clock_gettime(CLOCK_MONOTONIC, &data->eval_time->started_at);
+  JS_SetInterruptHandler(JS_GetRuntime(data->context), interrupt_handler, data->eval_time);
+
+  JSValue j_result = JS_Call(data->context, j_func, j_this, nargs, (JSValueConst *)j_args);
+
+  JS_FreeValue(data->context, j_func);
+  JS_FreeValue(data->context, j_this);
+  if (j_args)
+  {
+    for (int i = 0; i < nargs; i++)
+      JS_FreeValue(data->context, j_args[i]);
+    free(j_args);
+  }
+
+  // js_std_await handles both async (promise) and sync results; frees j_result
+  return to_rb_return_value(data->context, js_std_await(data->context, j_result));
+}
+
 static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
 {
   VALUE r_import_string, r_opts;
@@ -850,16 +994,6 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   return Qtrue;
 }
 
-static VALUE vm_m_logs(VALUE r_self)
-{
-  rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "Quickjs::VM#logs is deprecated; use Quickjs::VM#on_log instead");
-
-  VMData *data;
-  TypedData_Get_Struct(r_self, VMData, &vm_type, data);
-
-  return data->logs;
-}
-
 RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
 {
   rb_require("json");
@@ -873,9 +1007,9 @@ RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
   rb_define_alloc_func(r_class_vm, vm_alloc);
   rb_define_method(r_class_vm, "initialize", vm_m_initialize, -1);
   rb_define_method(r_class_vm, "eval_code", vm_m_evalCode, 1);
+  rb_define_method(r_class_vm, "call", vm_m_callGlobalFunction, -1);
   rb_define_method(r_class_vm, "define_function", vm_m_defineGlobalFunction, -1);
   rb_define_method(r_class_vm, "import", vm_m_import, -1);
-  rb_define_method(r_class_vm, "logs", vm_m_logs, 0);
   rb_define_method(r_class_vm, "on_log", vm_m_on_log, 0);
   r_define_log_class(r_class_vm);
 }

data/ext/quickjsrb/quickjsrb.h

@@ -18,6 +18,8 @@ extern const uint32_t qjsc_polyfill_file_min_size;
 extern const uint8_t qjsc_polyfill_file_min;
 extern const uint32_t qjsc_polyfill_encoding_min_size;
 extern const uint8_t qjsc_polyfill_encoding_min;
+extern const uint32_t qjsc_polyfill_url_min_size;
+extern const uint8_t qjsc_polyfill_url_min;
 
 extern const char *featureStdId;
 extern const char *featureOsId;
@@ -25,6 +27,8 @@ extern const char *featureTimeoutId;
 extern const char *featurePolyfillIntlId;
 extern const char *featurePolyfillFileId;
 extern const char *featurePolyfillEncodingId;
+extern const char *featurePolyfillUrlId;
+extern const char *featurePolyfillCryptoId;
 
 extern const char *undefinedId;
 extern const char *nanId;
@@ -48,7 +52,6 @@ typedef struct VMData
   struct JSContext *context;
   VALUE defined_functions;
   struct EvalTime *eval_time;
-  VALUE logs;
   VALUE log_listener;
   VALUE alive_objects;
   JSValue j_file_proxy_creator;
@@ -80,7 +83,6 @@ static void vm_mark(void *ptr)
 {
   VMData *data = (VMData *)ptr;
   rb_gc_mark_movable(data->defined_functions);
-  rb_gc_mark_movable(data->logs);
   rb_gc_mark_movable(data->log_listener);
   rb_gc_mark_movable(data->alive_objects);
 }
@@ -89,7 +91,6 @@ static void vm_compact(void *ptr)
 {
   VMData *data = (VMData *)ptr;
   data->defined_functions = rb_gc_location(data->defined_functions);
-  data->logs = rb_gc_location(data->logs);
   data->log_listener = rb_gc_location(data->log_listener);
   data->alive_objects = rb_gc_location(data->alive_objects);
 }
@@ -110,7 +111,6 @@ static VALUE vm_alloc(VALUE r_self)
   VMData *data;
   VALUE obj = TypedData_Make_Struct(r_self, VMData, &vm_type, data);
   data->defined_functions = rb_hash_new();
-  data->logs = rb_ary_new();
   data->log_listener = Qnil;
   data->alive_objects = rb_hash_new();
   data->j_file_proxy_creator = JS_UNDEFINED;
@@ -156,6 +156,8 @@ static void r_define_constants(VALUE r_parent_class)
   rb_define_const(r_parent_class, "POLYFILL_INTL", QUICKJSRB_SYM(featurePolyfillIntlId));
   rb_define_const(r_parent_class, "POLYFILL_FILE", QUICKJSRB_SYM(featurePolyfillFileId));
   rb_define_const(r_parent_class, "POLYFILL_ENCODING", QUICKJSRB_SYM(featurePolyfillEncodingId));
+  rb_define_const(r_parent_class, "POLYFILL_URL", QUICKJSRB_SYM(featurePolyfillUrlId));
+  rb_define_const(r_parent_class, "POLYFILL_CRYPTO", QUICKJSRB_SYM(featurePolyfillCryptoId));
 
   VALUE rb_cQuickjsValue = rb_define_class_under(r_parent_class, "Value", rb_cObject);
   rb_define_const(rb_cQuickjsValue, "UNDEFINED", QUICKJSRB_SYM(undefinedId));

data/ext/quickjsrb/quickjsrb_crypto.c

@@ -0,0 +1,71 @@
+#include "quickjsrb.h"
+#include "quickjsrb_crypto.h"
+#include "quickjsrb_crypto_subtle.h"
+
+static VALUE r_secure_random()
+{
+  return rb_const_get(rb_cObject, rb_intern("SecureRandom"));
+}
+
+static JSValue js_crypto_get_random_values(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+  if (argc < 1)
+    return JS_ThrowTypeError(ctx, "Failed to execute 'getRandomValues': 1 argument required, but only 0 present.");
+
+  size_t byte_offset, byte_length, bytes_per_element;
+  JSValue j_buffer = JS_GetTypedArrayBuffer(ctx, argv[0], &byte_offset, &byte_length, &bytes_per_element);
+  if (JS_IsException(j_buffer))
+    return JS_EXCEPTION;
+
+  JSValue j_ctor = JS_GetPropertyStr(ctx, argv[0], "constructor");
+  JSValue j_name = JS_GetPropertyStr(ctx, j_ctor, "name");
+  const char *name = JS_ToCString(ctx, j_name);
+  int is_float = name && (strcmp(name, "Float16Array") == 0 ||
+                          strcmp(name, "Float32Array") == 0 ||
+                          strcmp(name, "Float64Array") == 0);
+  JS_FreeCString(ctx, name);
+  JS_FreeValue(ctx, j_name);
+  JS_FreeValue(ctx, j_ctor);
+
+  if (is_float)
+  {
+    JS_FreeValue(ctx, j_buffer);
+    return JS_ThrowTypeError(ctx, "Failed to execute 'getRandomValues': The provided ArrayBufferView value must not be of floating-point type.");
+  }
+
+  if (byte_length > 65536)
+  {
+    JS_FreeValue(ctx, j_buffer);
+    return JS_ThrowRangeError(ctx, "Failed to execute 'getRandomValues': The ArrayBufferView's byte length exceeds the number of bytes of entropy available via this API (65536).");
+  }
+
+  size_t buf_size;
+  uint8_t *buf = JS_GetArrayBuffer(ctx, &buf_size, j_buffer);
+  JS_FreeValue(ctx, j_buffer);
+
+  if (!buf)
+    return JS_ThrowTypeError(ctx, "Failed to execute 'getRandomValues': Failed to get ArrayBuffer.");
+
+  VALUE r_random_bytes = rb_funcall(r_secure_random(), rb_intern("random_bytes"), 1, SIZET2NUM(byte_length));
+  const uint8_t *random_buf = (const uint8_t *)RSTRING_PTR(r_random_bytes);
+  memcpy(buf + byte_offset, random_buf, byte_length);
+
+  return JS_DupValue(ctx, argv[0]);
+}
+
+static JSValue js_crypto_random_uuid(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
+{
+  VALUE r_uuid = rb_funcall(r_secure_random(), rb_intern("uuid"), 0);
+  return JS_NewString(ctx, StringValueCStr(r_uuid));
+}
+
+void quickjsrb_init_crypto(JSContext *ctx, JSValue j_global)
+{
+  JSValue j_crypto = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, j_crypto, "getRandomValues",
+                    JS_NewCFunction(ctx, js_crypto_get_random_values, "getRandomValues", 1));
+  JS_SetPropertyStr(ctx, j_crypto, "randomUUID",
+                    JS_NewCFunction(ctx, js_crypto_random_uuid, "randomUUID", 0));
+  quickjsrb_init_crypto_subtle(ctx, j_crypto);
+  JS_SetPropertyStr(ctx, j_global, "crypto", j_crypto);
+}

data/ext/quickjsrb/quickjsrb_crypto.h

@@ -0,0 +1,6 @@
+#ifndef QUICKJSRB_CRYPTO_H
+#define QUICKJSRB_CRYPTO_H 1
+
+void quickjsrb_init_crypto(JSContext *ctx, JSValue j_global);
+
+#endif /* QUICKJSRB_CRYPTO_H */